@airtable/blocks 1.9.0-experimental-5565d56-20211029 → 1.10.1

package/dist/cjs/models/view_data_store.js

@@ -2,7 +2,13 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-require("core-js/modules/es.array.find");
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.array.map");
 
@@ -10,17 +16,17 @@ require("core-js/modules/es.array.slice");
 
 require("core-js/modules/es.object.to-string");
 
-require("core-js/modules/es.object.values");
-
 require("core-js/modules/es.promise");
 
-require("core-js/modules/web.dom-collections.for-each");
+require("core-js/modules/web.dom-collections.iterator");
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.WatchableViewDataStoreKeys = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -29,9 +35,11 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
@@ -43,12 +51,11 @@ var _private_utils = require("../private_utils");
 
 var _error_utils = require("../error_utils");
 
-var _block_query_spec = require("../types/block_query_spec");
-
 var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
 
 var WatchableViewDataStoreKeys = Object.freeze({
   visibleRecords: 'visibleRecords',
+  visibleRecordIds: 'visibleRecordIds',
   groups: 'groups',
   groupLevels: 'groupLevels',
   recordColors: 'recordColors',
@@ -59,11 +66,9 @@ var WatchableViewDataStoreKeys = Object.freeze({
 
 exports.WatchableViewDataStoreKeys = WatchableViewDataStoreKeys;
 
-// ViewDataStore manages loadable data for a specific view. That means the set of visible records,
+// ViewDataStore contains loadable data for a specific view. That means the set of visible records,
 // and field order/visibility information. View itself only contains core schema information. The
-// data here doesn't belong in View as it's record data or conditionally loaded and therefore
-// loaded via queries (and therefore managed by publicAirtableInterface)
-// TODO: (#proj-blocks-sdk-record-limits) Remove AbstractModelWithAsyncData
+// data here doesn't belong in View as it's record data or conditionally loaded.
 
 /** @internal */
 var ViewDataStore =
@@ -75,6 +80,11 @@ function (_AbstractModelWithAsy) {
     value: function _isWatchableKey(key) {
       return (0, _private_utils.isEnumValue)(WatchableViewDataStoreKeys, key);
     }
+  }, {
+    key: "_shouldLoadDataForKey",
+    value: function _shouldLoadDataForKey(key) {
+      return true;
+    }
   }]);
 
   function ViewDataStore(sdk, parentRecordStore, viewId) {
@@ -84,38 +94,16 @@ function (_AbstractModelWithAsy) {
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ViewDataStore).call(this, sdk, "".concat(viewId, "-ViewDataStore")));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "viewId", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "parentRecordStore", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_publicViewStore", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryManager", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryIdFromReferenceCountedLoadData", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_mostRecentTableLoadPromise", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_airtableInterface", void 0);
     _this.parentRecordStore = parentRecordStore;
-    _this._queryManager = sdk._queryManager;
+    _this._airtableInterface = sdk.__airtableInterface;
+    _this._mostRecentTableLoadPromise = null;
     _this.viewId = viewId;
-
-    var publicViewStore = _this.parentRecordStore._airtableInterface.getViewMetadataStoreIfExists(_this.parentRecordStore.tableId, viewId);
-
-    (0, _error_utils.invariant)(publicViewStore, 'PublicViewStore must exist for all valid viewIds');
-    _this._publicViewStore = publicViewStore;
     return _this;
   }
 
   (0, _createClass2.default)(ViewDataStore, [{
-    key: "_assertExistsAndLoaded",
-
-    /**
-     * @internal
-     */
-    value: function _assertExistsAndLoaded() {
-      // Access data in order to throw if the data has been deleted / isn't loaded
-      var data = this._dataOrNullIfDeleted; // Currently it is not possible for the ViewDataStore to spawn an error on deletion
-      // because the parent TableOrViewQueryResult or ViewMetadataQueryResult throw their own
-      // errors when the view is deleted.
-      // istanbul ignore if
-
-      if (data === null) {
-        throw this._spawnErrorForDeletion();
-      }
-    }
-  }, {
     key: "_onChangeIsDataLoaded",
     value: function _onChangeIsDataLoaded() {// noop
     }
@@ -123,58 +111,212 @@ function (_AbstractModelWithAsy) {
     key: "__onDataDeletion",
     value: function __onDataDeletion() {
       this._forceUnload();
-
-      this._queryManager.forceUnloadWatchesOnWatchableModel(this);
+    }
+  }, {
+    key: "loadDataAsync",
+    value: function loadDataAsync() {
+      var tableLoadPromise;
+      return _regenerator.default.async(function loadDataAsync$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              // Override this method to also load table data.
+              // NOTE: it's important that we call loadDataAsync on the table here and not in
+              // _loadDataAsync since we want the retain counts for the view and table to increase/decrease
+              // in lock-step. If we load table data in _loadDataAsync, the table's retain
+              // count only increments some of the time, which leads to unexpected behavior.
+              tableLoadPromise = this.parentRecordStore.loadRecordMetadataAsync();
+              this._mostRecentTableLoadPromise = tableLoadPromise;
+              _context.next = 4;
+              return _regenerator.default.awrap((0, _get2.default)((0, _getPrototypeOf2.default)(ViewDataStore.prototype), "loadDataAsync", this).call(this));
+
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, null, this);
     }
   }, {
     key: "_loadDataAsync",
     value: function _loadDataAsync() {
-      var changedKeysOnLoad;
-      return _regenerator.default.async(function _loadDataAsync$(_context) {
+      var tableLoadPromise, _ref, _ref2, viewData, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, record;
+
+      return _regenerator.default.async(function _loadDataAsync$(_context2) {
         while (1) {
-          switch (_context.prev = _context.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
-              // TODO: (#proj-blocks-sdk-record-limits) Do we want to remove this reference counting semantic?
-              // We can assume that each query is identical, but it might be helpful to have all queries be
-              // registered across the bridge so that we can track utilization.
-              (0, _error_utils.invariant)(this._queryIdFromReferenceCountedLoadData === null, 'Can not reissue an identical view data store query');
-              _context.next = 3;
-              return _regenerator.default.awrap(this._queryManager.fetchAndSubscribeToQueryAsync({
-                sourceType: _block_query_spec.BlockQuerySourceType.VIEW,
-                sourceTableId: this.parentRecordStore.tableId,
-                sourceViewId: this.viewId,
-                viewMetadataSelection: {
-                  shouldIncludeVisibleRecordIds: true,
-                  shouldIncludeFieldOrder: true,
-                  shouldIncludeGroups: true,
-                  shouldIncludeGroupingLevels: true,
-                  shouldIncludeColorsForRecordId: true
+              // We need to be sure that the table data is loaded *before* we return
+              // from this method.
+              (0, _error_utils.invariant)(this._mostRecentTableLoadPromise, 'No table load promise');
+              tableLoadPromise = this._mostRecentTableLoadPromise;
+              _context2.next = 4;
+              return _regenerator.default.awrap(Promise.all([this._airtableInterface.fetchAndSubscribeToViewDataAsync(this.parentRecordStore.tableId, this.viewId), tableLoadPromise]));
+
+            case 4:
+              _ref = _context2.sent;
+              _ref2 = (0, _slicedToArray2.default)(_ref, 1);
+              viewData = _ref2[0];
+              this._data.visibleRecordIds = viewData.visibleRecordIds;
+              this._data.fieldOrder = viewData.fieldOrder;
+              this._data.groups = viewData.groups;
+              this._data.groupLevels = viewData.groupLevels;
+              this._data.colorsByRecordId = viewData.colorsByRecordId;
+
+              if (!this._data.colorsByRecordId) {
+                _context2.next = 32;
+                break;
+              }
+
+              _iteratorNormalCompletion = true;
+              _didIteratorError = false;
+              _iteratorError = undefined;
+              _context2.prev = 16;
+
+              for (_iterator = this.visibleRecords[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                record = _step.value;
+
+                if ((0, _private_utils.has)(this._data.colorsByRecordId, record.id)) {
+                  record.__triggerOnChangeForRecordColorInViewId(this.viewId);
                 }
-              }));
+              }
 
-            case 3:
-              this._queryIdFromReferenceCountedLoadData = _context.sent;
-              changedKeysOnLoad = Object.values(WatchableViewDataStoreKeys);
+              _context2.next = 24;
+              break;
 
-              this._queryManager.onLoadKeys(this, changedKeysOnLoad);
+            case 20:
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](16);
+              _didIteratorError = true;
+              _iteratorError = _context2.t0;
 
-              return _context.abrupt("return", []);
+            case 24:
+              _context2.prev = 24;
+              _context2.prev = 25;
 
-            case 7:
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+
+            case 27:
+              _context2.prev = 27;
+
+              if (!_didIteratorError) {
+                _context2.next = 30;
+                break;
+              }
+
+              throw _iteratorError;
+
+            case 30:
+              return _context2.finish(27);
+
+            case 31:
+              return _context2.finish(24);
+
+            case 32:
+              return _context2.abrupt("return", [WatchableViewDataStoreKeys.visibleRecords, WatchableViewDataStoreKeys.visibleRecordIds, WatchableViewDataStoreKeys.allFieldIds, WatchableViewDataStoreKeys.groups, WatchableViewDataStoreKeys.groupLevels, WatchableViewDataStoreKeys.visibleFieldIds, WatchableViewDataStoreKeys.recordColors]);
+
+            case 33:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
         }
-      }, null, this);
+      }, null, this, [[16, 20, 24, 32], [25,, 27, 31]]);
+    }
+  }, {
+    key: "unloadData",
+    value: function unloadData() {
+      // Override this method to also unload the table's data.
+      // NOTE: it's important that we do this here, since we want the view and table's
+      // retain counts to increment/decrement in lock-step. If we unload the table's
+      // data in _unloadData, it leads to unexpected behavior.
+      (0, _get2.default)((0, _getPrototypeOf2.default)(ViewDataStore.prototype), "unloadData", this).call(this);
+      this.parentRecordStore.unloadRecordMetadata();
     }
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      (0, _error_utils.invariant)(this._queryIdFromReferenceCountedLoadData, 'Can not unsubscribe from a view store that is not subscribed');
+      this._mostRecentTableLoadPromise = null;
+
+      this._airtableInterface.unsubscribeFromViewData(this.parentRecordStore.tableId, this.viewId);
+
+      if (!this.isDeleted) {
+        this._data.visibleRecordIds = undefined;
+        this._data.groups = undefined;
+        this._data.colorsByRecordId = undefined;
+      }
+    }
+  }, {
+    key: "__generateChangesForParentTableAddMultipleRecords",
+    value: function __generateChangesForParentTableAddMultipleRecords(recordIds) {
+      var newVisibleRecordIds = [...this.visibleRecordIds, ...recordIds];
+      return [{
+        path: ['tablesById', this.parentRecordStore.tableId, 'viewsById', this.viewId, 'visibleRecordIds'],
+        value: newVisibleRecordIds
+      }];
+    }
+  }, {
+    key: "__generateChangesForParentTableDeleteMultipleRecords",
+    value: function __generateChangesForParentTableDeleteMultipleRecords(recordIds) {
+      var recordIdsToDeleteSet = {};
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = recordIds[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var recordId = _step2.value;
+          recordIdsToDeleteSet[recordId] = true;
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      var newVisibleRecordIds = this.visibleRecordIds.filter(recordId => !recordIdsToDeleteSet[recordId]);
+      var changePayload = [{
+        path: ['tablesById', this.parentRecordStore.tableId, 'viewsById', this.viewId, 'visibleRecordIds'],
+        value: newVisibleRecordIds
+      }];
+
+      if (this._data.groups) {
+        var newGroups = this.__recursivelyRemoveRecordsFromGroupsInPlace((0, _private_utils.cloneDeep)(this._data.groups), recordIdsToDeleteSet);
+
+        changePayload.push({
+          path: ['tablesById', this.parentRecordStore.tableId, 'viewsById', this.viewId, 'groups'],
+          value: newGroups
+        });
+      }
+
+      return changePayload;
+    }
+  }, {
+    key: "__recursivelyRemoveRecordsFromGroupsInPlace",
+    value: function __recursivelyRemoveRecordsFromGroupsInPlace(groups, recordIdsToDeleteSet) {
+      if (!groups || groups.length === 0) {
+        return groups;
+      }
 
-      this._queryManager.unsubscribeFromQueryId(this._queryIdFromReferenceCountedLoadData);
+      return groups.map(group => {
+        if (group.visibleRecordIds) {
+          group.visibleRecordIds = group.visibleRecordIds.filter(id => !recordIdsToDeleteSet[id]);
+        }
+
+        this.__recursivelyRemoveRecordsFromGroupsInPlace(group.groups, recordIdsToDeleteSet);
 
-      this._queryIdFromReferenceCountedLoadData = null;
+        return group;
+      });
     }
     /**
      * The record IDs that are not filtered out of this view.
@@ -192,187 +334,107 @@ function (_AbstractModelWithAsy) {
      * @param recordOrRecordId the record/record id to get the color for
      */
     value: function getRecordColor(record) {
-      (0, _error_utils.invariant)(this.isDataLoaded, 'View data is not loaded');
-
-      this._assertExistsAndLoaded();
-
-      return this._publicViewStore.getColorForRecordId(record.id);
-    }
-  }, {
-    key: "_findBlockSubscriptionChangedMatchingSubscriptionChangeTypeForViewIfExists",
-    value: function _findBlockSubscriptionChangedMatchingSubscriptionChangeTypeForViewIfExists(changes, changeTypeToMatch) {
-      var _changes$find;
+      var _ref3, _this$_data$colorsByR;
 
-      return (_changes$find = changes.find(change => change.type === changeTypeToMatch && change.tableId === this.parentRecordStore.tableId && change.viewId === this.viewId)) !== null && _changes$find !== void 0 ? _changes$find : null;
+      (0, _error_utils.invariant)(this.isDataLoaded, 'View data is not loaded');
+      return (_ref3 = (_this$_data$colorsByR = this._data.colorsByRecordId) === null || _this$_data$colorsByR === void 0 ? void 0 : _this$_data$colorsByR[record.id]) !== null && _ref3 !== void 0 ? _ref3 : null;
     }
   }, {
-    key: "_constructBlockQuerySpecForWatchableKey",
-    value: function _constructBlockQuerySpecForWatchableKey(key, callbackForRegistration, context) {
-      var querySpecOptions = {};
-
-      var wrappedCallbackForQueryChange = () => {
-        callbackForRegistration.call(context, this, key);
-      };
-
-      switch (key) {
-        case WatchableViewDataStoreKeys.visibleRecords:
-          querySpecOptions.shouldIncludeVisibleRecordIds = true;
-          break;
-
-        case WatchableViewDataStoreKeys.groups:
-          {
-            querySpecOptions.shouldIncludeGroups = true;
-            break;
-          }
-
-        case WatchableViewDataStoreKeys.groupLevels:
-          {
-            querySpecOptions.shouldIncludeGroupingLevels = true;
-            break;
-          }
-
-        case WatchableViewDataStoreKeys.recordColors:
-          {
-            querySpecOptions.shouldIncludeColorsForRecordId = true;
+    key: "triggerOnChangeForDirtyPaths",
+    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {
+      if (dirtyPaths.visibleRecordIds) {
+        this._onChange(WatchableViewDataStoreKeys.visibleRecords);
 
-            wrappedCallbackForQueryChange = changes => {
-              var recordColorsChange = this._findBlockSubscriptionChangedMatchingSubscriptionChangeTypeForViewIfExists(changes, _block_query_spec.BlockQuerySubscriptionChangeType.CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW);
+        this._onChange(WatchableViewDataStoreKeys.visibleRecordIds);
+      }
 
-              var recordIdsOrNull = null;
+      if (dirtyPaths.fieldOrder) {
+        this._onChange(WatchableViewDataStoreKeys.allFieldIds); // TODO(kasra): only trigger visibleFields if the *visible* field ids changed.
 
-              if (recordColorsChange) {
-                (0, _error_utils.invariant)(recordColorsChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW, 'Invalid record colors change event');
-                recordIdsOrNull = recordColorsChange.recordIds;
-              } // We also always call this, even if no recordColors changed to closely mirror
-              // the old version of the SDK (https://github.com/Hyperbase/blocks-sdk/blob/8e3ac1a37be9c9850e64085975b102a483116080/packages/sdk/src/models/view_data_store.ts#L319-L361)
-              // In the future, this should not be the case (don't call callback if nothing changed)
 
+        this._onChange(WatchableViewDataStoreKeys.visibleFieldIds);
+      } // Technically it's possible for groupLevels changing to cause a groups
+      // change since we derive group information from the groupLevels (fieldId)
 
-              callbackForRegistration.call(context, this, key, recordIdsOrNull);
-            };
 
-            break;
-          }
+      if (dirtyPaths.groups || dirtyPaths.groupLevels) {
+        this._onChange(WatchableViewDataStoreKeys.groups);
+      }
 
-        case WatchableViewDataStoreKeys.allFieldIds:
-          {
-            querySpecOptions.shouldIncludeFieldOrder = true;
-            break;
-          }
+      if (dirtyPaths.groupLevels) {
+        this._onChange(WatchableViewDataStoreKeys.groupLevels);
+      }
 
-        case WatchableViewDataStoreKeys.visibleFieldIds:
-          {
-            // TODO: This will trigger even if fieldIds which aren't visible in the view change.
-            // This is NOT a regression, a fix would be to add an intermediate callback
-            // which swallows changes if the visible fieldOrder does not change.
-            querySpecOptions.shouldIncludeFieldOrder = true;
-            break;
+      if (dirtyPaths.colorsByRecordId) {
+        var changedRecordIds = dirtyPaths.colorsByRecordId._isDirty ? null : Object.keys(dirtyPaths.colorsByRecordId);
+
+        if (changedRecordIds) {
+          // Checking isRecordMetadataLoaded fixes a timing issue:
+          // When a new table loads in liveapp, we'll receive the record
+          // colors before getting the response to our loadData call.
+          // This is a temporary fix: we need a more general solution to
+          // avoid processing events associated with subscriptions whose
+          // data we haven't received yet.
+          if (this.parentRecordStore.isRecordMetadataLoaded) {
+            var _iteratorNormalCompletion3 = true;
+            var _didIteratorError3 = false;
+            var _iteratorError3 = undefined;
+
+            try {
+              for (var _iterator3 = changedRecordIds[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                var recordId = _step3.value;
+                var record = this.parentRecordStore.getRecordByIdIfExists(recordId); // Similar to above, we could be receiving the change notification
+                // for a record color before receiving the new record itself.
+
+                if (record) {
+                  record.__triggerOnChangeForRecordColorInViewId(this.viewId);
+                }
+              }
+            } catch (err) {
+              _didIteratorError3 = true;
+              _iteratorError3 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                  _iterator3.return();
+                }
+              } finally {
+                if (_didIteratorError3) {
+                  throw _iteratorError3;
+                }
+              }
+            }
           }
-        // TypeScript ensures that key is of type never so we don't need to test this via istanbul
-        // istanbul ignore next
+        }
 
-        default:
-          throw (0, _error_utils.spawnExhaustiveSwitchError)(key);
+        this._onChange(WatchableViewDataStoreKeys.recordColors, changedRecordIds);
       }
-
-      return {
-        querySpecToSubscribeWith: {
-          sourceType: _block_query_spec.BlockQuerySourceType.VIEW,
-          sourceTableId: this.parentRecordStore.tableId,
-          sourceViewId: this.viewId,
-          viewMetadataSelection: querySpecOptions
-        },
-        wrappedCallbackForQueryChange
-      };
-    }
-    /**
-     * Watching a key that needs to load data asynchronously will automatically
-     * cause the data to be fetched. Once the data is available, the callback
-     * will be called.
-     *
-     * @inheritdoc
-     */
-
-  }, {
-    key: "watch",
-    value: function watch(keys, callbackForWatchKey, context) {
-      this._assertNotForceUnloaded();
-
-      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'view watch');
-
-      validKeys.forEach(validKey => {
-        var _this$_constructBlock = this._constructBlockQuerySpecForWatchableKey(validKey, callbackForWatchKey, context),
-            querySpecToSubscribeWith = _this$_constructBlock.querySpecToSubscribeWith,
-            wrappedCallbackForQueryChange = _this$_constructBlock.wrappedCallbackForQueryChange;
-
-        this._queryManager.watchWithQuerySpec(querySpecToSubscribeWith, this, validKey, wrappedCallbackForQueryChange, callbackForWatchKey, context);
-      });
-      return validKeys;
-    }
-    /**
-     * Unwatching a key that needs to load data asynchronously will automatically
-     * cause the data to be released. Once the data is available, the callback
-     * will be called.
-     *
-     * @inheritdoc
-     */
-
-  }, {
-    key: "unwatch",
-    value: function unwatch(keys, callbackForRegistration, context) {
-      // We have already unsubscribed from all watches (because query-based watches force data to be loaded)
-      // so no watches are subscribed
-      if (this._isForceUnloaded) {
-        return [];
-      } // We warn instead of throw here because we used to warn instead of throw and don't
-      // want to make a breaking change.
-
-
-      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'view unwatch', true);
-
-      validKeys.forEach(key => this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context));
-      return validKeys;
-    }
-  }, {
-    key: "triggerOnChangeForDirtyPaths",
-    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {// This is only triggered for changes to values in the type ViewData, which is
-      // populated and kept up to date by watching base schema (aka the view's id, name, type).
-      // None of these are watchable, so we don't need to call this._onChange() for them.
-      // In the future we may want to make the view's name watchable, which is the only property
-      // here that we'd expect to change. In this case, it would be handled here.
     }
   }, {
     key: "_dataOrNullIfDeleted",
     get: function get() {
-      var _ref;
+      var _ref4;
 
       var tableData = this._baseData.tablesById[this.parentRecordStore.tableId];
-      return (_ref = tableData === null || tableData === void 0 ? void 0 : tableData.viewsById[this.viewId]) !== null && _ref !== void 0 ? _ref : null;
+      return (_ref4 = tableData === null || tableData === void 0 ? void 0 : tableData.viewsById[this.viewId]) !== null && _ref4 !== void 0 ? _ref4 : null;
     }
   }, {
     key: "isDataLoaded",
     get: function get() {
-      return this._isDataLoaded;
-    }
-  }, {
-    key: "isRecordDataLoadedForView",
-    get: function get() {
-      // We _currently_ only issue queries that also load cell data in the view which
-      // is synchronously returned with all other view data, so we can collapse this
-      // to if the viewData has loaded.
-      // TODO: (#proj-blocks-sdk-record-limits) Actually track if all cell data is loaded
-      // based on issued queries from ViewDataStore
-      return this.isDataLoaded;
+      return this._isDataLoaded && this.parentRecordStore.isRecordMetadataLoaded;
     }
   }, {
     key: "visibleRecordIds",
     get: function get() {
-      this._assertExistsAndLoaded(); // Freezing the visibleRecordIds happens on the other side of the bridge
-
+      var visibleRecordIds = this._data.visibleRecordIds;
+      (0, _error_utils.invariant)(visibleRecordIds, 'View data is not loaded'); // Freeze visibleRecordIds so users can't mutate it.
+      // If it changes from liveapp, we get an entire new array which will
+      // replace this one, so it's okay to freeze it.
 
-      var visibleRecordIds = this._publicViewStore.getVisibleRecordIds();
+      if (!Object.isFrozen(visibleRecordIds)) {
+        Object.freeze(visibleRecordIds);
+      }
 
-      (0, _error_utils.invariant)(visibleRecordIds, 'View data is not loaded');
       return visibleRecordIds;
     }
     /**
@@ -384,12 +446,8 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "visibleRecords",
     get: function get() {
-      (0, _error_utils.invariant)(this.isRecordDataLoadedForView, 'Table data is not loaded for this view');
-
-      this._assertExistsAndLoaded();
-
-      var visibleRecordIds = this._publicViewStore.getVisibleRecordIds();
-
+      (0, _error_utils.invariant)(this.parentRecordStore.isRecordMetadataLoaded, 'Table data is not loaded');
+      var visibleRecordIds = this._data.visibleRecordIds;
       (0, _error_utils.invariant)(visibleRecordIds, 'View data is not loaded');
       return visibleRecordIds.map(recordId => {
         var record = this.parentRecordStore.getRecordByIdIfExists(recordId);
@@ -408,9 +466,9 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "groups",
     get: function get() {
-      this._assertExistsAndLoaded();
-
-      return this._publicViewStore.getGroups();
+      (0, _error_utils.invariant)(this.parentRecordStore.isRecordMetadataLoaded, 'Table data is not loaded');
+      var groups = this._data.groups;
+      return groups !== null && groups !== void 0 ? groups : null;
     }
     /**
      * Gets the group config for this view, can be watched to know when groupLevels
@@ -420,29 +478,23 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "groupLevels",
     get: function get() {
-      this._assertExistsAndLoaded();
-
-      return this._publicViewStore.getGroupLevels();
+      (0, _error_utils.invariant)(this.parentRecordStore.isRecordMetadataLoaded, 'Table data is not loaded');
+      var groupLevels = this._data.groupLevels;
+      return groupLevels !== null && groupLevels !== void 0 ? groupLevels : null;
     }
   }, {
     key: "allFieldIds",
     get: function get() {
-      this._assertExistsAndLoaded(); // TODO: (#proj-blocks-sdk-record-limits) Future sdk version shouldn't deep
-      // copy this, and it should be legal to return the frozen object directly
-
-
-      return (0, _private_utils.cloneDeep)(this._publicViewStore.getFieldOrder().fieldIds);
+      var fieldOrder = this._data.fieldOrder;
+      (0, _error_utils.invariant)(fieldOrder, 'View data is not loaded');
+      return fieldOrder.fieldIds;
     }
   }, {
     key: "visibleFieldIds",
     get: function get() {
-      this._assertExistsAndLoaded();
-
-      var fieldOrder = this._publicViewStore.getFieldOrder();
-
+      var fieldOrder = this._data.fieldOrder;
       (0, _error_utils.invariant)(fieldOrder, 'View data is not loaded');
-      var fieldIds = fieldOrder.fieldIds; // Slice returns a mutable copy even though visibleFieldCount is readonly
-
+      var fieldIds = fieldOrder.fieldIds;
       return fieldIds.slice(0, fieldOrder.visibleFieldCount);
     }
   }]);