@airtable/blocks 0.0.0-experimental-20e3506bd-20250428

package/dist/cjs/base/models/record_store.js

@@ -0,0 +1,825 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WatchableRecordStoreKeys = void 0;
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.object.entries.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.string.starts-with.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+var _record_store_core = _interopRequireWildcard(require("../../shared/models/record_store_core"));
+var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
+var _record = _interopRequireDefault(require("./record"));
+var _view_data_store = _interopRequireDefault(require("./view_data_store"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var WatchableRecordStoreKeys = exports.WatchableRecordStoreKeys = Object.freeze(_objectSpread({}, _record_store_core.WatchableRecordStoreKeysCore));
+
+/**
+ * The string case is to accommodate prefix keys
+ *
+ * @internal
+ */
+/**
+ * One RecordStore exists per table, and contains all the record data associated with that table.
+ * Table itself is for schema information only, so isn't the appropriate place for this data.
+ *
+ * @internal
+ */
+var RecordStore = /*#__PURE__*/function (_RecordStoreCore) {
+  function RecordStore(sdk, tableId) {
+    var _this;
+    (0, _classCallCheck2.default)(this, RecordStore);
+    _this = _callSuper(this, RecordStore, [sdk, tableId]);
+    (0, _defineProperty2.default)(_this, "_viewDataStoresByViewId", {});
+    (0, _defineProperty2.default)(_this, "_loader", void 0);
+    var onChange = _this._onChange.bind(_this);
+    var clearRecordModels = () => {
+      _this._recordModelsById = {};
+    };
+    _this._loader = new RecordStoreAsyncLoader(sdk, tableId, onChange, clearRecordModels);
+    return _this;
+  }
+  (0, _inherits2.default)(RecordStore, _RecordStoreCore);
+  return (0, _createClass2.default)(RecordStore, [{
+    key: "_constructRecord",
+    value: function _constructRecord(recordId, parentTable) {
+      return new _record.default(this._sdk, this, parentTable, recordId);
+    }
+  }, {
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      return this._loader._dataOrNullIfDeleted;
+    }
+  }, {
+    key: "getViewDataStore",
+    value: function getViewDataStore(viewId) {
+      if (this._viewDataStoresByViewId[viewId]) {
+        return this._viewDataStoresByViewId[viewId];
+      }
+      (0, _error_utils.invariant)(this._data.viewsById[viewId], 'view must exist');
+      var viewDataStore = new _view_data_store.default(this._sdk, this, viewId);
+      this._viewDataStoresByViewId[viewId] = viewDataStore;
+      return viewDataStore;
+    }
+  }, {
+    key: "watch",
+    value: function watch(keys, callback, context) {
+      var _this2 = this;
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "watch", this).call(this, keys, callback, context);
+      var fieldIdsToLoad = this._loader._getFieldIdsToLoadFromWatchableKeys(validKeys);
+      if (fieldIdsToLoad.length > 0) {
+        (0, _private_utils.fireAndForgetPromise)( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+          return _regenerator.default.wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return _this2._loader.loadCellValuesInFieldIdsAsync(fieldIdsToLoad, _this2._onChange.bind(_this2));
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        })));
+      }
+      return validKeys;
+    }
+  }, {
+    key: "unwatch",
+    value: function unwatch(keys, callback, context) {
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "unwatch", this).call(this, keys, callback, context);
+      var fieldIdsToUnload = this._loader._getFieldIdsToLoadFromWatchableKeys(validKeys);
+      if (fieldIdsToUnload.length > 0) {
+        this._loader.unloadCellValuesInFieldIds(fieldIdsToUnload);
+      }
+      return validKeys;
+    }
+
+    /**
+     * The record IDs in this table. The order is arbitrary since records are
+     * only ordered in the context of a specific view.
+     */
+  }, {
+    key: "recordIds",
+    get: function get() {
+      var recordsById = this._data.recordsById;
+      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+      return Object.keys(recordsById);
+    }
+  }, {
+    key: "__onDataDeletion",
+    value: function __onDataDeletion() {
+      // also need to call unloadCellValuesInFieldIds because otherwise
+      // on the hyperbase side, the old record store would still be subscribed
+      // to the cell values and it will refuse a request for new subscription
+      for (var _i = 0, _Object$keys = Object.keys(this._loader._cellValuesRetainCountByFieldId); _i < _Object$keys.length; _i++) {
+        var fieldId = _Object$keys[_i];
+        while (this._loader._cellValuesRetainCountByFieldId[fieldId] && this._loader._cellValuesRetainCountByFieldId[fieldId] > 0) {
+          this._loader.unloadCellValuesInFieldIds([fieldId]);
+        }
+      }
+      this._loader._forceUnload();
+
+      // similarly unsubscribe from the view data.
+      // this comes after _forceUnload to avoid over releasing the table data.
+      var _iterator = _createForOfIteratorHelper((0, _private_utils.values)(this._viewDataStoresByViewId)),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var viewDataStore = _step.value;
+          viewDataStore.__onDataDeletion();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    // #region async data loading
+    // wrapper methods over RecordStoreAsyncLoader
+  }, {
+    key: "isDeleted",
+    get: function get() {
+      return this._loader.isDeleted || (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "isDeleted", this);
+    }
+  }, {
+    key: "isDataLoaded",
+    get: function get() {
+      return !this.isDeleted && this._loader.isDataLoaded;
+    }
+  }, {
+    key: "loadDataAsync",
+    value: function () {
+      var _loadDataAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this._loader.loadDataAsync();
+            case 2:
+              return _context2.abrupt("return", _context2.sent);
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function loadDataAsync() {
+        return _loadDataAsync.apply(this, arguments);
+      }
+      return loadDataAsync;
+    }()
+  }, {
+    key: "unloadData",
+    value: function unloadData() {
+      return this._loader.unloadData();
+    }
+  }, {
+    key: "isRecordMetadataLoaded",
+    get: function get() {
+      return this._loader.isRecordMetadataLoaded;
+    }
+  }, {
+    key: "loadRecordMetadataAsync",
+    value: function () {
+      var _loadRecordMetadataAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this._loader.loadRecordMetadataAsync(this._onChange.bind(this));
+            case 2:
+              return _context3.abrupt("return", _context3.sent);
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function loadRecordMetadataAsync() {
+        return _loadRecordMetadataAsync.apply(this, arguments);
+      }
+      return loadRecordMetadataAsync;
+    }()
+  }, {
+    key: "unloadRecordMetadata",
+    value: function unloadRecordMetadata() {
+      return this._loader.unloadRecordMetadata();
+    }
+  }, {
+    key: "areCellValuesLoadedForFieldId",
+    value: function areCellValuesLoadedForFieldId(fieldId) {
+      return this._loader.areCellValuesLoadedForFieldId(fieldId);
+    }
+  }, {
+    key: "loadCellValuesInFieldIdsAsync",
+    value: function () {
+      var _loadCellValuesInFieldIdsAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(fieldIds) {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this._loader.loadCellValuesInFieldIdsAsync(fieldIds, this._onChange.bind(this));
+            case 2:
+              return _context4.abrupt("return", _context4.sent);
+            case 3:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function loadCellValuesInFieldIdsAsync(_x) {
+        return _loadCellValuesInFieldIdsAsync.apply(this, arguments);
+      }
+      return loadCellValuesInFieldIdsAsync;
+    }()
+  }, {
+    key: "unloadCellValuesInFieldIds",
+    value: function unloadCellValuesInFieldIds(fieldIds) {
+      return this._loader.unloadCellValuesInFieldIds(fieldIds);
+    }
+    // #endregion
+  }, {
+    key: "triggerOnChangeForDirtyPaths",
+    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {
+      if (this.isRecordMetadataLoaded && dirtyPaths.recordsById) {
+        (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "triggerOnChangeForDirtyPaths", this).call(this, dirtyPaths);
+      }
+      if (dirtyPaths.viewOrder) {
+        // clean up deleted views
+        var _iterator2 = _createForOfIteratorHelper((0, _private_utils.entries)(this._viewDataStoresByViewId)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
+              viewId = _step2$value[0],
+              viewDataStore = _step2$value[1];
+            if (viewDataStore.isDeleted) {
+              viewDataStore.__onDataDeletion();
+              delete this._viewDataStoresByViewId[viewId];
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableRecordStoreKeys, key) || key.startsWith(_record_store_core.WatchableCellValuesInFieldKeyPrefix);
+    }
+  }]);
+}(_record_store_core.default);
+/** @internal */
+(0, _defineProperty2.default)(RecordStore, "_className", 'RecordStore');
+var RecordStoreAsyncLoader = /*#__PURE__*/function (_AbstractModelWithAsy) {
+  function RecordStoreAsyncLoader(sdk, tableId, onChange, clearRecordModels) {
+    var _this3;
+    (0, _classCallCheck2.default)(this, RecordStoreAsyncLoader);
+    _this3 = _callSuper(this, RecordStoreAsyncLoader, [sdk, "".concat(tableId, "-RecordStore")]);
+    (0, _defineProperty2.default)(_this3, "tableId", void 0);
+    (0, _defineProperty2.default)(_this3, "_airtableInterface", void 0);
+    (0, _defineProperty2.default)(_this3, "_primaryFieldId", void 0);
+    (0, _defineProperty2.default)(_this3, "_onChange", void 0);
+    (0, _defineProperty2.default)(_this3, "_clearRecordModels", void 0);
+    // There is a lot of duplication here and in AbstractModelWithAsyncData.
+    // Alternatively, phase out AbstractModelWithAsyncData as a superclass
+    // and instead create a helper class for managing each part of the data
+    // tree that is loaded.
+    (0, _defineProperty2.default)(_this3, "_areCellValuesLoadedByFieldId", {});
+    (0, _defineProperty2.default)(_this3, "_pendingCellValuesLoadPromiseByFieldId", {});
+    (0, _defineProperty2.default)(_this3, "_cellValuesRetainCountByFieldId", {});
+    (0, _defineProperty2.default)(_this3, "_timeoutForRemovingFieldIds", null);
+    _this3._airtableInterface = sdk.__airtableInterface;
+    _this3.tableId = tableId;
+    _this3._onChange = onChange;
+    _this3._clearRecordModels = clearRecordModels;
+    // A bit of a hack, but we use the primary field ID to load record
+    // metadata (see _getFieldIdForCausingRecordMetadataToLoad). We copy the
+    // ID here instead of calling this.primaryField.id since that would crash
+    // when the table is getting unloaded after being deleted.
+    _this3._primaryFieldId = _this3._data.primaryFieldId;
+    return _this3;
+  }
+  (0, _inherits2.default)(RecordStoreAsyncLoader, _AbstractModelWithAsy);
+  return (0, _createClass2.default)(RecordStoreAsyncLoader, [{
+    key: "_onChangeIsDataLoaded",
+    value: function _onChangeIsDataLoaded() {
+      // noop
+    }
+
+    /**
+     * Record metadata means record IDs, createdTime, and commentCount are loaded.
+     * Record metadata must be loaded before creating, deleting, or updating records.
+     */
+  }, {
+    key: "isRecordMetadataLoaded",
+    get: function get() {
+      return !!this._data.recordsById;
+    }
+  }, {
+    key: "loadRecordMetadataAsync",
+    value: function () {
+      var _loadRecordMetadataAsync2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(onChange) {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.loadCellValuesInFieldIdsAsync([this._getFieldIdForCausingRecordMetadataToLoad()], onChange);
+            case 2:
+              return _context5.abrupt("return", _context5.sent);
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function loadRecordMetadataAsync(_x2) {
+        return _loadRecordMetadataAsync2.apply(this, arguments);
+      }
+      return loadRecordMetadataAsync;
+    }()
+  }, {
+    key: "unloadRecordMetadata",
+    value: function unloadRecordMetadata() {
+      this.unloadCellValuesInFieldIds([this._getFieldIdForCausingRecordMetadataToLoad()]);
+    }
+  }, {
+    key: "_getFieldIdsToLoadFromWatchableKeys",
+    value: function _getFieldIdsToLoadFromWatchableKeys(keys) {
+      var fieldIdsToLoad = [];
+      var _iterator3 = _createForOfIteratorHelper(keys),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var key = _step3.value;
+          if (key.startsWith(_record_store_core.WatchableCellValuesInFieldKeyPrefix)) {
+            var fieldId = key.substring(_record_store_core.WatchableCellValuesInFieldKeyPrefix.length);
+            fieldIdsToLoad.push(fieldId);
+          } else if (key === WatchableRecordStoreKeys.records || key === WatchableRecordStoreKeys.recordIds) {
+            fieldIdsToLoad.push(this._getFieldIdForCausingRecordMetadataToLoad());
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return fieldIdsToLoad;
+    }
+  }, {
+    key: "_getFieldIdForCausingRecordMetadataToLoad",
+    value: function _getFieldIdForCausingRecordMetadataToLoad() {
+      // As a shortcut, we'll load the primary field cell values to
+      // cause record metadata (id, createdTime, commentCount) to be loaded
+      // and subscribed to. In the future, we could add an explicit model
+      // bridge to fetch and subscribe to row metadata.
+      return this._primaryFieldId;
+    }
+  }, {
+    key: "areCellValuesLoadedForFieldId",
+    value: function areCellValuesLoadedForFieldId(fieldId) {
+      return this.isDataLoaded || this._areCellValuesLoadedByFieldId[fieldId] || false;
+    }
+  }, {
+    key: "loadCellValuesInFieldIdsAsync",
+    value: function () {
+      var _loadCellValuesInFieldIdsAsync2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(fieldIds, onChange) {
+        var fieldIdsWhichAreNotAlreadyLoadedOrLoading, pendingLoadPromises, _iterator4, _step4, _fieldId, pendingLoadPromise, loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise, _iterator5, _step5, fieldId;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              this._assertNotForceUnloaded();
+              fieldIdsWhichAreNotAlreadyLoadedOrLoading = [];
+              pendingLoadPromises = [];
+              _iterator4 = _createForOfIteratorHelper(fieldIds);
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  _fieldId = _step4.value;
+                  if (this._cellValuesRetainCountByFieldId[_fieldId] !== undefined) {
+                    this._cellValuesRetainCountByFieldId[_fieldId]++;
+                  } else {
+                    this._cellValuesRetainCountByFieldId[_fieldId] = 1;
+                  }
+
+                  // NOTE: we don't use this.areCellValuesLoadedForFieldId() here because
+                  // that will return true if the cell values are loaded as a result
+                  // of the entire table being loaded. In that scenario, we still
+                  // want to separately load the cell values for the field so there
+                  // is a separate subscription. Otherwise, when the table data unloads,
+                  // the field data would unload as well. This can be improved by just
+                  // subscribing to the field data without fetching it, since the cell
+                  // values are already in the block frame.
+                  if (!this._areCellValuesLoadedByFieldId[_fieldId]) {
+                    pendingLoadPromise = this._pendingCellValuesLoadPromiseByFieldId[_fieldId];
+                    if (pendingLoadPromise) {
+                      pendingLoadPromises.push(pendingLoadPromise);
+                    } else {
+                      fieldIdsWhichAreNotAlreadyLoadedOrLoading.push(_fieldId);
+                    }
+                  }
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+              if (fieldIdsWhichAreNotAlreadyLoadedOrLoading.length > 0) {
+                // Could inline _loadCellValuesInFieldIdsAsync, but following the
+                // pattern from AbstractModelWithAsyncData where the public method
+                // is responsible for updating retain counts and the private method
+                // actually fetches data.
+                loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise = this._loadCellValuesInFieldIdsAsync(fieldIdsWhichAreNotAlreadyLoadedOrLoading);
+                pendingLoadPromises.push(loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise);
+                _iterator5 = _createForOfIteratorHelper(fieldIdsWhichAreNotAlreadyLoadedOrLoading);
+                try {
+                  for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                    fieldId = _step5.value;
+                    this._pendingCellValuesLoadPromiseByFieldId[fieldId] = loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise;
+                  }
+                  // Doing `.then` instead of performing these actions directly in
+                  // _loadCellValuesInFieldIdsAsync so this is similar to
+                  // AbstractModelWithAsyncData. The idea is to refactor to avoid code
+                  // duplication, so keeping them similar for now hopefully will make the
+                  // refactor simpler.
+                } catch (err) {
+                  _iterator5.e(err);
+                } finally {
+                  _iterator5.f();
+                }
+                loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise.then(changedKeys => {
+                  var _iterator6 = _createForOfIteratorHelper(fieldIdsWhichAreNotAlreadyLoadedOrLoading),
+                    _step6;
+                  try {
+                    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                      var fieldId = _step6.value;
+                      this._areCellValuesLoadedByFieldId[fieldId] = true;
+                      this._pendingCellValuesLoadPromiseByFieldId[fieldId] = undefined;
+                    }
+                  } catch (err) {
+                    _iterator6.e(err);
+                  } finally {
+                    _iterator6.f();
+                  }
+                  var _iterator7 = _createForOfIteratorHelper(changedKeys),
+                    _step7;
+                  try {
+                    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+                      var key = _step7.value;
+                      onChange(key);
+                    }
+                  } catch (err) {
+                    _iterator7.e(err);
+                  } finally {
+                    _iterator7.f();
+                  }
+                });
+              }
+              // Since we are incrementing fieldIds, it's necessary to restart any pending timeouts
+              // to unload data. This is because it's possible for a timeout to fire while a queryResult
+              // is actively unloading, and erroneously unload data. Data must be unloaded _after_ the queryResult.
+              this._restartTimeoutToUnloadFieldIdsIfTimeoutIsActive();
+              _context6.next = 9;
+              return Promise.all(pendingLoadPromises);
+            case 9:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function loadCellValuesInFieldIdsAsync(_x3, _x4) {
+        return _loadCellValuesInFieldIdsAsync2.apply(this, arguments);
+      }
+      return loadCellValuesInFieldIdsAsync;
+    }()
+  }, {
+    key: "_loadCellValuesInFieldIdsAsync",
+    value: function () {
+      var _loadCellValuesInFieldIdsAsync3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(fieldIds) {
+        var _yield$this$_airtable, newRecordsById, existingRecordsById, _iterator8, _step8, _step8$value, recordId, newRecordObj, existingRecordObj, isCommentCountTypesSame, isCreatedTimeTypesSame, existingCellValuesByFieldId, i, fieldId, changedKeys;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 2;
+              return this._airtableInterface.fetchAndSubscribeToCellValuesInFieldsAsync(this.tableId, fieldIds);
+            case 2:
+              _yield$this$_airtable = _context7.sent;
+              newRecordsById = _yield$this$_airtable.recordsById;
+              // Merge with existing data.
+              if (!this._data.recordsById) {
+                this._data.recordsById = {};
+              }
+              existingRecordsById = this._data.recordsById;
+              _iterator8 = _createForOfIteratorHelper((0, _private_utils.entries)((0, _private_utils.cast)(newRecordsById)));
+              try {
+                for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                  _step8$value = (0, _slicedToArray2.default)(_step8.value, 2), recordId = _step8$value[0], newRecordObj = _step8$value[1];
+                  if (!(0, _private_utils.has)(existingRecordsById, recordId)) {
+                    existingRecordsById[recordId] = newRecordObj;
+                  } else {
+                    existingRecordObj = existingRecordsById[recordId]; // Metadata (createdTime, commentCount) should generally be up to date,
+                    // but can be out of date in the rare scenario where realtime
+                    // data has not yet been delivered to the SDK, but is populated in hyperbase
+                    // at the time this new fetch is executed.
+                    // istanbul ignore next
+                    if (existingRecordObj.commentCount !== newRecordObj.commentCount) {
+                      isCommentCountTypesSame = typeof existingRecordObj.commentCount !== typeof newRecordObj.commentCount;
+                      (0, _error_utils.logErrorToSentry)('comment count out of sync - types are same: %s', {
+                        isCommentCountTypesSame
+                      });
+                    }
+
+                    // istanbul ignore next
+                    if (existingRecordObj.createdTime !== newRecordObj.createdTime) {
+                      isCreatedTimeTypesSame = typeof existingRecordObj.createdTime !== typeof newRecordObj.createdTime;
+                      (0, _error_utils.logErrorToSentry)('created time out of sync - types are same: %s', {
+                        isCreatedTimeTypesSame
+                      });
+                    }
+                    if (!existingRecordObj.cellValuesByFieldId) {
+                      existingRecordObj.cellValuesByFieldId = {};
+                    }
+                    existingCellValuesByFieldId = existingRecordObj.cellValuesByFieldId;
+                    for (i = 0; i < fieldIds.length; i++) {
+                      fieldId = fieldIds[i];
+                      existingCellValuesByFieldId[fieldId] = newRecordObj.cellValuesByFieldId ? newRecordObj.cellValuesByFieldId[fieldId] : undefined;
+                    }
+                  }
+                }
+              } catch (err) {
+                _iterator8.e(err);
+              } finally {
+                _iterator8.f();
+              }
+              changedKeys = fieldIds.map(fieldId => _record_store_core.WatchableCellValuesInFieldKeyPrefix + fieldId); // Need to trigger onChange for records and recordIds since watching either
+              // of those causes record metadata to be loaded (via _getFieldIdForCausingRecordMetadataToLoad)
+              // and by convention we trigger a change event when data loads.
+              changedKeys.push(WatchableRecordStoreKeys.records);
+              changedKeys.push(WatchableRecordStoreKeys.recordIds);
+              // Also trigger cellValues changes since the cell values in the fields
+              // are now loaded.
+              changedKeys.push(WatchableRecordStoreKeys.cellValues);
+              return _context7.abrupt("return", changedKeys);
+            case 13:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function _loadCellValuesInFieldIdsAsync(_x5) {
+        return _loadCellValuesInFieldIdsAsync3.apply(this, arguments);
+      }
+      return _loadCellValuesInFieldIdsAsync;
+    }()
+  }, {
+    key: "unloadCellValuesInFieldIds",
+    value: function unloadCellValuesInFieldIds(fieldIds) {
+      if (this._isForceUnloaded) {
+        return;
+      }
+      var _iterator9 = _createForOfIteratorHelper(fieldIds),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var fieldId = _step9.value;
+          var fieldRetainCount = this._cellValuesRetainCountByFieldId[fieldId] || 0;
+          fieldRetainCount--;
+          if (fieldRetainCount < 0) {
+            console.log('Field data over-released'); // eslint-disable-line no-console
+            fieldRetainCount = 0;
+          }
+          this._cellValuesRetainCountByFieldId[fieldId] = fieldRetainCount;
+        }
+        // Don't unload immediately. Wait a while in case something else
+        // requests the data, so we can avoid going back to liveapp or
+        // the network.
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+      this._startTimeoutToUnloadForFieldIdsIfNeeded();
+    }
+
+    // This unloads all fields where the retain count is at zero, and if any other
+    // request to unload fields is pending - cancels it and restarts it.
+    // This is important because fields must always be unloaded at least __DATA_UNLOAD_DELAY_MS
+    // after the unload is requested so that any QueryResults relying on them properly
+    // unload either first, or at the same time
+  }, {
+    key: "_startTimeoutToUnloadForFieldIdsIfNeeded",
+    value: function _startTimeoutToUnloadForFieldIdsIfNeeded() {
+      var fieldIdsWithZeroRetainCount = [];
+      for (var _i2 = 0, _Object$entries = Object.entries(this._cellValuesRetainCountByFieldId); _i2 < _Object$entries.length; _i2++) {
+        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i2], 2),
+          fieldId = _Object$entries$_i[0],
+          retainCount = _Object$entries$_i[1];
+        if (retainCount === 0) {
+          fieldIdsWithZeroRetainCount.push(fieldId);
+        }
+      }
+
+      // Cancel any pending timeouts before proceeding
+      // This should be canceled even if there aren't any fields to unload as that means
+      // that there has been loading that's occured that makes the pending request invalid
+      if (this._timeoutForRemovingFieldIds) {
+        clearTimeout(this._timeoutForRemovingFieldIds);
+        this._timeoutForRemovingFieldIds = null;
+      }
+      if (fieldIdsWithZeroRetainCount.length > 0) {
+        this._timeoutForRemovingFieldIds = setTimeout(() => {
+          // Make sure the retain count is still zero, since it may
+          // have been incremented before the timeout fired.
+          var fieldIdsToUnload = fieldIdsWithZeroRetainCount.filter(fieldId => {
+            // It's necessary to also check that the field is loaded, as it's possible
+            // for an unload to trigger with fields that have already been removed.
+            return this._cellValuesRetainCountByFieldId[fieldId] === 0 && this._areCellValuesLoadedByFieldId[fieldId];
+          });
+          // istanbul ignore else
+          if (fieldIdsToUnload.length > 0) {
+            // Set _areCellValuesLoadedByFieldId to false before calling _unloadCellValuesInFieldIds
+            // since _unloadCellValuesInFieldIds will check if *any* fields are still loaded.
+            var _iterator10 = _createForOfIteratorHelper(fieldIdsToUnload),
+              _step10;
+            try {
+              for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+                var _fieldId2 = _step10.value;
+                this._areCellValuesLoadedByFieldId[_fieldId2] = false;
+              }
+            } catch (err) {
+              _iterator10.e(err);
+            } finally {
+              _iterator10.f();
+            }
+            this._unloadCellValuesInFieldIds(fieldIdsToUnload);
+          } else {
+            // This shouldn't be possible because we always cancel the timer if fieldIds loadedness
+            // status ever changes
+            (0, _error_utils.logErrorToSentry)('fieldIdsToUnload is empty, this likely means the unload timer is not properly reset.');
+          }
+          this._timeoutForRemovingFieldIds = null;
+        }, _abstract_model_with_async_data.default.__DATA_UNLOAD_DELAY_MS);
+      }
+    }
+  }, {
+    key: "_restartTimeoutToUnloadFieldIdsIfTimeoutIsActive",
+    value: function _restartTimeoutToUnloadFieldIdsIfTimeoutIsActive() {
+      if (this._timeoutForRemovingFieldIds) {
+        this._startTimeoutToUnloadForFieldIdsIfNeeded();
+      }
+    }
+  }, {
+    key: "_unloadCellValuesInFieldIds",
+    value: function _unloadCellValuesInFieldIds(fieldIds) {
+      this._airtableInterface.unsubscribeFromCellValuesInFields(this.tableId, fieldIds);
+      this._afterUnloadDataOrUnloadCellValuesInFieldIds(fieldIds);
+    }
+  }, {
+    key: "_loadDataAsync",
+    value: function () {
+      var _loadDataAsync2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        var tableData, changedKeys, _iterator11, _step11, fieldId;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return this._airtableInterface.fetchAndSubscribeToTableDataAsync(this.tableId);
+            case 2:
+              tableData = _context8.sent;
+              this._data.recordsById = tableData.recordsById;
+              changedKeys = [WatchableRecordStoreKeys.records, WatchableRecordStoreKeys.recordIds, WatchableRecordStoreKeys.cellValues];
+              _iterator11 = _createForOfIteratorHelper((0, _private_utils.keys)(this._data.fieldsById));
+              try {
+                for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+                  fieldId = _step11.value;
+                  changedKeys.push(_record_store_core.WatchableCellValuesInFieldKeyPrefix + fieldId);
+                }
+              } catch (err) {
+                _iterator11.e(err);
+              } finally {
+                _iterator11.f();
+              }
+              return _context8.abrupt("return", changedKeys);
+            case 8:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function _loadDataAsync() {
+        return _loadDataAsync2.apply(this, arguments);
+      }
+      return _loadDataAsync;
+    }()
+  }, {
+    key: "_unloadData",
+    value: function _unloadData() {
+      this._airtableInterface.unsubscribeFromTableData(this.tableId);
+      this._afterUnloadDataOrUnloadCellValuesInFieldIds();
+    }
+  }, {
+    key: "_afterUnloadDataOrUnloadCellValuesInFieldIds",
+    value: function _afterUnloadDataOrUnloadCellValuesInFieldIds(unloadedFieldIds) {
+      var areAnyFieldsLoaded = this.isDataLoaded || (0, _private_utils.values)(this._areCellValuesLoadedByFieldId).some(isLoaded => isLoaded);
+      if (!this.isDeleted) {
+        if (!areAnyFieldsLoaded) {
+          this._data.recordsById = undefined;
+        } else if (!this.isDataLoaded) {
+          var fieldIdsToClear;
+          // This should be impossible - for fields should always be loaded
+          // when attempting to unload specific fields. This codepath was previously possible
+          // due to a bug. It could be converted to an invariant, but that is higher risk.
+          // istanbul ignore if
+          if (unloadedFieldIds) {
+            // Specific fields were unloaded, so clear out the cell values for those fields.
+            fieldIdsToClear = unloadedFieldIds;
+            (0, _error_utils.logErrorToSentry)('Field Ids are being unloaded when record_store is unloaded');
+          } else {
+            // The entire table was unloaded, but some individual fields are still loaded.
+            // We need to clear out the cell values of every field that was unloaded.
+            // This is kind of slow, but hopefully uncommon.
+            var fieldIds = Object.keys(this._data.fieldsById);
+            fieldIdsToClear = fieldIds.filter(fieldId => !this._areCellValuesLoadedByFieldId[fieldId]);
+          }
+          var recordsById = this._data.recordsById;
+          var _iterator12 = _createForOfIteratorHelper((0, _private_utils.values)(recordsById || {})),
+            _step12;
+          try {
+            for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+              var recordObj = _step12.value;
+              for (var i = 0; i < fieldIdsToClear.length; i++) {
+                var fieldId = fieldIdsToClear[i];
+                if (recordObj.cellValuesByFieldId) {
+                  recordObj.cellValuesByFieldId[fieldId] = undefined;
+                }
+              }
+            }
+          } catch (err) {
+            _iterator12.e(err);
+          } finally {
+            _iterator12.f();
+          }
+        }
+      }
+      if (!areAnyFieldsLoaded) {
+        this._clearRecordModels();
+      }
+    }
+  }, {
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      var _this$_baseData$table;
+      return (_this$_baseData$table = this._baseData.tablesById[this.tableId]) !== null && _this$_baseData$table !== void 0 ? _this$_baseData$table : null;
+    }
+  }], [{
+    key: "_shouldLoadDataForKey",
+    value: function _shouldLoadDataForKey(key) {
+      // "Data" means *all* cell values in the table. If only watching records/recordIds,
+      // we'll just load record metadata (id, createdTime, commentCount).
+      // If only watching specific fields, we'll just load cell values in those
+      // fields. Both of those scenarios are handled manually by this class,
+      // instead of relying on AbstractModelWithAsyncData.
+      return key === WatchableRecordStoreKeys.cellValues;
+    }
+  }]);
+}(_abstract_model_with_async_data.default);
+/** @internal */
+var _default = exports.default = RecordStore;