@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-3649c7162-20250904

package/dist/esm/base/models/table_or_view_query_result.js

@@ -0,0 +1,749 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+var _table = _interopRequireWildcard(require("./table"));
+var _record_query_result = _interopRequireDefault(require("./record_query_result"));
+var _record_coloring = require("./record_coloring");
+var _object_pool = _interopRequireDefault(require("./object_pool"));
+var _record_store = require("./record_store");
+var _view_data_store = _interopRequireWildcard(require("./view_data_store"));
+var _grouped_record_query_result = _interopRequireDefault(require("./grouped_record_query_result"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (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; }
+/** @module @airtable/blocks/models: RecordQueryResult */ /** */
+
+/** @hidden */
+
+/**
+ * Represents a set of records directly from a view or table. See {@link RecordQueryResult} for main
+ * documentation.
+ *
+ * Do not instantiate. You can get instances of this class by calling
+ * `table.selectRecords` or `view.selectRecords`.
+ *
+ * @docsPath models/query results/TableOrViewQueryResult
+ */
+class TableOrViewQueryResult extends _record_query_result.default {
+  /** @internal */
+  static _className = 'TableOrViewQueryResult';
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  // If custom sorts or groups are specified, we'll use a VisList to handle sorting.
+  // If no sorts are specified, we'll use the underlying row order of the source model.
+  // Note: we're currently handling visibility tracking for view query results within this class,
+  // not in the VisList. In other words, only visible records are added to the visList.
+  /** @internal */
+
+  /** @internal */
+
+  // These is the groupLevels provided to us by the user when executing a query
+  /** @internal */
+
+  // This is the ordered list of record ids.
+  /** @internal */
+
+  // This is the ordered list of groups.
+  /** @internal */
+
+  // An ordered list of group levels returned to us from hyperbase, this should not be
+  // read from directly, but instead via this.data.groupLevels (Writing to this on hyperbase updates).
+  // (which check's that this model has not been not deleted)
+  /** @internal */
+
+  // lazily generated set of record ids
+  /** @internal */
+  _recordIdsSet = null;
+
+  // NOTE: when a cellValue key (cellValues or cellValuesInField:) is watched, we want
+  // to make sure we watch the associated key on the table. However, we need to make
+  // sure that we only watch the table once for each key. Otherwise, the callbacks
+  // for each key will get called more than once for each change event. This is because
+  // Watchable stores references to callbacks for each key, and on each _onChange event
+  // calls each callback for that key. If we watch the table more than once, then we'll
+  // call _onChange more than once, and each callback will be called more than once, which
+  // is undesirable. Instead, we'll store watch counts for each key to make sure we only
+  // watch the table once.
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+  constructor(sdk, sourceModel, normalizedOpts) {
+    super(sdk, normalizedOpts);
+    this._sourceModel = sourceModel;
+    this._mostRecentSourceModelLoadPromise = null;
+    this._table = normalizedOpts.table;
+    const {
+      sorts
+    } = this._normalizedOpts;
+    this._sorts = sorts ?? null;
+    // TODO (SeanKeenan): Placeholder until we support groups from normalizedOpts
+    this._groupLevels = null;
+    this._visList = null;
+    this._orderedRecordIds = null;
+    this._orderedGroups = null;
+    this._loadedGroupLevels = null;
+    this._cellValueKeyWatchCounts = {};
+    let fieldIdsSetToLoadOrNullIfAllFields = null;
+    if (this._normalizedOpts.fieldIdsOrNullIfAllFields) {
+      fieldIdsSetToLoadOrNullIfAllFields = {};
+      for (const fieldId of this._normalizedOpts.fieldIdsOrNullIfAllFields) {
+        fieldIdsSetToLoadOrNullIfAllFields[fieldId] = true;
+      }
+      // Need to load data for fields we're sorting by, even if
+      // they're not explicitly requested in the `fields` opt.
+      if (this._sorts !== null) {
+        for (const sort of this._sorts) {
+          fieldIdsSetToLoadOrNullIfAllFields[sort.fieldId] = true;
+        }
+      }
+      // TODO (SeanKeenan): Comment back in when enabling groups
+      // Same for group configs
+      // if (this._groupLevels !== null) {
+      //     for (const group of this._groupLevels) {
+      //         fieldIdsSetToLoadOrNullIfAllFields[group.fieldId] = true;
+      //     }
+      // }
+
+      const recordColorMode = this._normalizedOpts.recordColorMode;
+      if (recordColorMode && recordColorMode.type === _record_coloring.ModeTypes.BY_SELECT_FIELD) {
+        fieldIdsSetToLoadOrNullIfAllFields[recordColorMode.selectField.id] = true;
+      }
+    }
+    this._fieldIdsSetToLoadOrNullIfAllFields = fieldIdsSetToLoadOrNullIfAllFields;
+    this.__groupedRecordQueryResultPool = new _object_pool.default(_grouped_record_query_result.default);
+    Object.seal(this);
+  }
+  /** @internal */
+  get _dataOrNullIfDeleted() {
+    if (this._sourceModel.isDeleted || this._recordStore.isDeleted) {
+      return null;
+    }
+    return {
+      recordIds: this._orderedRecordIds,
+      groups: this._orderedGroups,
+      groupLevels: this._loadedGroupLevels
+    };
+  }
+  /** @internal */
+  // istanbul ignore next
+  get __sourceModelId() {
+    return this._sourceModel.id;
+  }
+
+  /** @internal */
+  get __poolKey() {
+    return `${this._serializedOpts}::${this._sourceModel.id}`;
+  }
+
+  /**
+   * @internal (since we may not be able to return parent model instances in the immutable models world)
+   * The table that records in this RecordQueryResult are part of
+   */
+  get parentTable() {
+    return this._table;
+  }
+  /**
+   * @internal (since we may not be able to return parent model instances in the immutable models world)
+   * The view that was used to obtain this RecordQueryResult by calling
+   * `view.selectRecords`. Null if the RecordQueryResult was obtained by calling
+   * `table.selectRecords`.
+   */
+  get parentView() {
+    return this._sourceModel instanceof _table.default ? null : this._sourceModel;
+  }
+  /**
+   * The record IDs in this RecordQueryResult.
+   * Throws if data is not loaded yet.
+   * Can be watched.
+   */
+  get recordIds() {
+    // The following statements have been carefully sequenced to ensure
+    // that when this method fails, it reports the most salient error.
+    const {
+      recordIds
+    } = this._data; // Throws when the model has been deleted.
+    (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
+    (0, _error_utils.invariant)(recordIds, 'No recordIds');
+    return recordIds;
+  }
+  /**
+   * The ordered GroupedRecordQueryResult's in this RecordQueryResult.
+   * Throws if data is not loaded yet.
+   * Can be watched.
+   *
+   * @hidden
+   */
+  get groups() {
+    // The following statements have been carefully sequenced to ensure
+    // that when this method fails, it reports the most salient error.
+    const {
+      groups
+    } = this._data; // Throws when the model has been deleted.
+    (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
+    return groups ?? null;
+  }
+  /**
+   * The GroupLevels in this RecordQueryResult.
+   * Throws if data is not loaded yet.
+   * Can be watched.
+   *
+   * @hidden
+   */
+  get groupLevels() {
+    const {
+      groupLevels
+    } = this._data; // Throws when the model has been deleted.
+    (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
+    return groupLevels ? groupLevels.map(singleLevel => ({
+      ...singleLevel,
+      field: this.parentTable.getFieldById(singleLevel.fieldId)
+    })) : null;
+  }
+  /**
+   * The set of record IDs in this RecordQueryResult.
+   * Throws if data is not loaded yet.
+   *
+   * @internal
+   */
+  _getOrGenerateRecordIdsSet() {
+    if (!this._recordIdsSet) {
+      const recordIdsSet = {};
+      for (const recordId of this.recordIds) {
+        recordIdsSet[recordId] = true;
+      }
+      this._recordIdsSet = recordIdsSet;
+    }
+    return this._recordIdsSet;
+  }
+  /**
+   * The fields that were used to create this RecordQueryResult.
+   * Null if fields were not specified, which means the RecordQueryResult
+   * will load all fields in the table.
+   */
+  get fields() {
+    const {
+      fieldIdsOrNullIfAllFields
+    } = this._normalizedOpts;
+    if (fieldIdsOrNullIfAllFields) {
+      const fields = [];
+      // Filter out any deleted fields, since RecordQueryResult is "live".
+      // It would be too cumbersome (and defeat part of the purpose of
+      // using RecordQueryResult) if the user had to manually watch for deletion
+      // on all the fields and recreate the RecordQueryResult.
+      for (const fieldId of fieldIdsOrNullIfAllFields) {
+        const field = this._table.getFieldByIdIfExists(fieldId);
+        if (field !== null) {
+          fields.push(field);
+        }
+      }
+      return fields;
+    } else {
+      return null;
+    }
+  }
+  /** @internal */
+  get _cellValuesForSortWatchKeys() {
+    return this._sorts ? this._sorts.map(sort => `cellValuesInField:${sort.fieldId}`) : [];
+  }
+  /** @internal */
+  get _cellValuesForGroupWatchKeys() {
+    // _groupLevels can not be specified by the user during the query yet
+    // istanbul ignore next
+    return this._groupLevels ? this._groupLevels.map(group => `cellValuesInField:${group.fieldId}`) : [];
+  }
+  /** @internal */
+  get _sourceModelRecordIds() {
+    return this._sourceModel instanceof _table.default ? this._recordStore.recordIds : this._recordStore.getViewDataStore(this._sourceModel.id).visibleRecordIds;
+  }
+  /** @internal */
+  get _sourceModelGroups() {
+    return this._sourceModel instanceof _table.default ? null : this._recordStore.getViewDataStore(this._sourceModel.id).groups;
+  }
+  /** @internal */
+  get _sourceModelGroupLevels() {
+    return this._sourceModel instanceof _table.default ? null : this._recordStore.getViewDataStore(this._sourceModel.id).groupLevels;
+  }
+  /** @internal */
+  get _sourceModelRecords() {
+    return this._sourceModel instanceof _table.default ? this._recordStore.records : this._recordStore.getViewDataStore(this._sourceModel.id).visibleRecords;
+  }
+  /** @internal */
+  _incrementCellValueKeyWatchCountAndWatchIfNecessary(key, watchCallback) {
+    if (!this._cellValueKeyWatchCounts[key]) {
+      this._cellValueKeyWatchCounts[key] = 0;
+      this._recordStore.watch(key, watchCallback, this);
+    }
+    this._cellValueKeyWatchCounts[key]++;
+  }
+  /** @internal */
+  _decrementCellValueKeyWatchCountAndUnwatchIfPossible(key, watchCallback) {
+    if (!this._cellValueKeyWatchCounts[key]) {
+      // Key isn't watched, so just skip it. This matches behavior of Watchable,
+      // where calling unwatch on a key that isn't watched just no-ops.
+      return;
+    }
+    this._cellValueKeyWatchCounts[key]--;
+    if (this._cellValueKeyWatchCounts[key] === 0) {
+      // We're down to zero watches for this key, so we can actually unwatch it now.
+      this._recordStore.unwatch(key, watchCallback, this);
+      delete this._cellValueKeyWatchCounts[key];
+    }
+  }
+  /** @inheritdoc */
+  watch(keys, callback, context) {
+    const validKeys = super.watch(keys, callback, context);
+    for (const key of validKeys) {
+      if (key.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
+        const fieldId = key.substring(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix.length);
+        if (this._fieldIdsSetToLoadOrNullIfAllFields && !(0, _private_utils.has)(this._fieldIdsSetToLoadOrNullIfAllFields, fieldId)) {
+          throw (0, _error_utils.spawnError)("Can't watch field because it wasn't included in RecordQueryResult fields: %s", fieldId);
+        }
+        this._incrementCellValueKeyWatchCountAndWatchIfNecessary(key, this._onCellValuesInFieldChanged);
+      }
+      if (key === _record_query_result.default.WatchableKeys.cellValues) {
+        if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+          for (const fieldId of Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields)) {
+            this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, this._onCellValuesChanged);
+          }
+        } else {
+          this._incrementCellValueKeyWatchCountAndWatchIfNecessary(key, this._onCellValuesChanged);
+        }
+      }
+    }
+    return validKeys;
+  }
+  /** @inheritdoc */
+  unwatch(keys, callback, context) {
+    const validKeys = super.unwatch(keys, callback, context);
+    for (const key of validKeys) {
+      if (key.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
+        this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(key, this._onCellValuesInFieldChanged);
+      }
+      if (key === _record_query_result.default.WatchableKeys.cellValues) {
+        if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+          for (const fieldId of Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields)) {
+            this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, this._onCellValuesChanged);
+          }
+        } else {
+          this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(key, this._onCellValuesChanged);
+        }
+      }
+    }
+    return validKeys;
+  }
+  /** @inheritdoc */
+  async loadDataAsync() {
+    let sourceModelLoadPromise;
+    let cellValuesInFieldsLoadPromise;
+    if (this._sourceModel.isDeleted) {
+      throw this._spawnErrorForDeletion();
+    }
+    if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+      cellValuesInFieldsLoadPromise = this._recordStore.loadCellValuesInFieldIdsAsync(Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields));
+    } else {
+      // Load all fields.
+      cellValuesInFieldsLoadPromise = this._recordStore.loadDataAsync();
+    }
+    if (this._sourceModel instanceof _table.default) {
+      if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+        sourceModelLoadPromise = this._recordStore.loadRecordMetadataAsync();
+      } else {
+        // table.loadDataAsync is a superset of loadRecordMetadataAsync,
+        // so no need to load record metadata again.
+        sourceModelLoadPromise = null;
+      }
+    } else {
+      sourceModelLoadPromise = this._recordStore.getViewDataStore(this._sourceModel.id).loadDataAsync();
+    }
+    this._mostRecentSourceModelLoadPromise = Promise.all([sourceModelLoadPromise, cellValuesInFieldsLoadPromise, this._loadRecordColorsAsync()]);
+    await super.loadDataAsync();
+  }
+
+  /**
+   * @internal
+   */
+  _getChangedKeysOnLoad() {
+    const changedKeys = [_record_query_result.default.WatchableKeys.records, _record_query_result.default.WatchableKeys.recordIds, _record_query_result.default.WatchableKeys.cellValues, _record_query_result.default.WatchableKeys.groups, _record_query_result.default.WatchableKeys.groupLevels];
+    const fieldIds = this._normalizedOpts.fieldIdsOrNullIfAllFields || this._table.fields.map(field => field.id);
+    for (const fieldId of fieldIds) {
+      changedKeys.push(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
+    }
+    return changedKeys;
+  }
+
+  /** @internal */
+  async _loadDataAsync() {
+    this._table.__tableOrViewQueryResultPool.registerObjectForReuseStrong(this);
+    (0, _error_utils.invariant)(this._mostRecentSourceModelLoadPromise, 'No source model load promises');
+    await this._mostRecentSourceModelLoadPromise;
+    if (this._sorts) {
+      this._replaceVisList();
+    }
+    this._orderedRecordIds = this._generateOrderedRecordIds();
+    this._orderedGroups = this._generateAndLoadOrderedGroups();
+    // The server provided value and developer supplied value are the same, no conversion needed
+    this._loadedGroupLevels = this._sourceModelGroupLevels;
+    if (this._sourceModel instanceof _table.default) {
+      this._recordStore.watch(_record_store.WatchableRecordStoreKeys.records, this._onRecordsChanged, this);
+    } else {
+      const viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id);
+      viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.visibleRecords, this._onRecordsChanged, this);
+      viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.groups, this._onGroupsChanged, this);
+      viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.groupLevels, this._onGroupLevelsChanged, this);
+    }
+    this._recordStore.watch(this._cellValuesForSortWatchKeys, this._onCellValuesForSortChanged, this);
+    this._recordStore.watch(this._cellValuesForGroupWatchKeys, this._onCellValuesForGroupChanged, this);
+    this._table.watch(_table.WatchableTableKeys.fields, this._onTableFieldsChanged, this);
+    if (this._sorts) {
+      for (const sort of this._sorts) {
+        const field = this._table.getFieldByIdIfExists(sort.fieldId);
+        if (field) {
+          field.watch('type', this._onFieldConfigChanged, this);
+          field.watch('options', this._onFieldConfigChanged, this);
+        }
+      }
+    }
+    return this._getChangedKeysOnLoad();
+  }
+  /** @inheritdoc */
+  unloadData() {
+    super.unloadData();
+    if (this._sourceModel instanceof _table.default) {
+      if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+        this._recordStore.unloadRecordMetadata();
+      } else {
+        this._recordStore.unloadData();
+      }
+    } else {
+      // If the view is deleted, we can't get a data store for it.
+      if (!this._sourceModel.isDeleted) {
+        this._recordStore.getViewDataStore(this._sourceModel.id).unloadData();
+      }
+    }
+    if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+      this._recordStore.unloadCellValuesInFieldIds(Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields));
+    }
+    this._unloadRecordColors();
+  }
+  /** @internal */
+  _unloadData() {
+    this._mostRecentSourceModelLoadPromise = null;
+    if (this._sourceModel instanceof _table.default) {
+      this._recordStore.unwatch(_record_store.WatchableRecordStoreKeys.records, this._onRecordsChanged, this);
+    } else {
+      if (!this._sourceModel.isDeleted) {
+        const viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id);
+        viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.visibleRecords, this._onRecordsChanged, this);
+        viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.groups, this._onGroupsChanged, this);
+        viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.groupLevels, this._onGroupLevelsChanged, this);
+      }
+    }
+    this._recordStore.unwatch(this._cellValuesForSortWatchKeys, this._onCellValuesForSortChanged, this);
+    this._recordStore.unwatch(this._cellValuesForGroupWatchKeys, this._onCellValuesForGroupChanged, this);
+    this._table.unwatch(_table.WatchableTableKeys.fields, this._onTableFieldsChanged, this);
+
+    // If the table is deleted, can't call getFieldById on it below.
+    if (!this._table.isDeleted && this._sorts) {
+      for (const sort of this._sorts) {
+        const field = this._table.getFieldByIdIfExists(sort.fieldId);
+        if (field) {
+          field.unwatch('type', this._onFieldConfigChanged, this);
+          field.unwatch('options', this._onFieldConfigChanged, this);
+        }
+      }
+    }
+    this._unloadOrderedGroupsIfNeeded();
+    this._visList = null;
+    this._orderedRecordIds = null;
+    this._recordIdsSet = null;
+    this._table.__tableOrViewQueryResultPool.unregisterObjectForReuseStrong(this);
+  }
+  /** @internal */
+  _addRecordIdsToVisList(recordIds) {
+    const visList = this._visList;
+    (0, _error_utils.invariant)(visList, 'No vis list');
+    for (const recordId of recordIds) {
+      const record = this._recordStore.getRecordByIdIfExists(recordId);
+      (0, _error_utils.invariant)(record, 'Record missing in table');
+      visList.addRecordData(record._data);
+    }
+  }
+  /** @internal */
+  _onGroupLevelsChanged(model, key, updates) {
+    this._loadedGroupLevels = this._sourceModelGroupLevels;
+    this._unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches();
+    this._onChange(_record_query_result.default.WatchableKeys.groupLevels);
+  }
+  /** @internal */
+  _onGroupsChanged(model, key, updates) {
+    this._unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches();
+  }
+  /** @internal */
+  _onRecordsChanged(model, key, updates) {
+    if (model instanceof _view_data_store.default) {
+      // For a view model, we don't get updates sent with the onChange event,
+      // so we need to manually generate updates based on the old and new
+      // recordIds.
+      (0, _error_utils.invariant)(this._orderedRecordIds, '_orderedRecordIds unset');
+      const visibleRecordIds = this._recordStore.getViewDataStore(model.viewId).visibleRecordIds;
+      const addedRecordIds = (0, _private_utils.arrayDifference)(visibleRecordIds, this._orderedRecordIds);
+      const removedRecordIds = (0, _private_utils.arrayDifference)(this._orderedRecordIds, visibleRecordIds);
+      updates = {
+        addedRecordIds,
+        removedRecordIds
+      };
+    }
+    if (!updates) {
+      // If there are no updates, do nothing, since we'll handle the initial
+      // callback when the record set is loaded (and we don't want to fire
+      // a records change twice with no data).
+      return;
+    }
+    const {
+      addedRecordIds,
+      removedRecordIds
+    } = updates;
+    if (this._sorts) {
+      const visList = this._visList;
+      (0, _error_utils.invariant)(visList, 'No vis list');
+      if (removedRecordIds.length > 0) {
+        visList.removeRecordIds(removedRecordIds);
+      }
+      if (addedRecordIds.length > 0) {
+        this._addRecordIdsToVisList(addedRecordIds);
+      }
+    }
+    if (this._recordIdsSet) {
+      for (const recordId of addedRecordIds) {
+        this._recordIdsSet[recordId] = true;
+      }
+      for (const recordId of removedRecordIds) {
+        this._recordIdsSet[recordId] = undefined;
+      }
+    }
+
+    // Now that we've applied our changes (if applicable), let's regenerate our recordIds.
+    this._orderedRecordIds = this._generateOrderedRecordIds();
+    this._onChange(_record_query_result.default.WatchableKeys.records, updates);
+    this._onChange(_record_query_result.default.WatchableKeys.recordIds, updates);
+  }
+  /** @internal */
+  // istanbul ignore next
+  _onCellValuesForGroupChanged(recordStore, key, recordIds, fieldId) {
+    // TODO(SeanKeenan): This isn't yet required as we don't yet support
+    // specifying groups for a custom query, and this will only be called
+    // if we specify groups (same as _onCellValuesForSortChanged)
+    // This functionality and _onCellValuesForSortChanged should be
+    // identical, but testing, validation, and careful thought is required.
+  }
+  /** @internal */
+  _onCellValuesForSortChanged(recordStore, key, recordIds, fieldId) {
+    if (!recordIds || !fieldId) {
+      // If there are no updates, do nothing, since we'll handle the initial
+      // callback when the record set is loaded (and we don't want to fire
+      // a records change twice with no data).
+      return;
+    }
+
+    // NOTE: this will only ever be called if we have sorts, so it's safe to assert that we have
+    // a vis list here.
+    const visList = this._visList;
+    (0, _error_utils.invariant)(visList, 'No vis list');
+    (0, _error_utils.invariant)(recordIds.length > 0, 'field ID set without a corresponding record ID');
+
+    // Only move recordIds that are already in the visList.
+    // It's possible to have recordId that is not currently in the visList since
+    // this callback can run before onRecordsChanged. (eg. when a deleted record is
+    // restored, this is triggered for that record but the record is not yet in the visList:
+    // onRecordsChanged actually adds it)
+    // Note: cell value changes that result in the records being filtered out trigger
+    //       onRecordsChanged on the View model, so we don't have to worry about that here.
+    const visListRecordIdsSet = new Set(visList.getOrderedRecordIds());
+    const recordIdsToMove = recordIds.filter(recordId => visListRecordIdsSet.has(recordId));
+    visList.removeRecordIds(recordIdsToMove);
+    this._addRecordIdsToVisList(recordIdsToMove);
+    this._orderedRecordIds = this._generateOrderedRecordIds();
+    const changeData = {
+      addedRecordIds: [],
+      removedRecordIds: []
+    };
+    this._onChange(_record_query_result.default.WatchableKeys.records, changeData);
+    this._onChange(_record_query_result.default.WatchableKeys.recordIds, changeData);
+  }
+  /** @internal */
+  _onFieldConfigChanged(_field, _key) {
+    // Field config changed for a field we rely on, so we need to replace our vis list.
+    // NOTE: this will only ever be called if we have sorts, so it's safe to assume we
+    // are using a vis list here.
+    this._replaceVisList();
+    this._orderedRecordIds = this._generateOrderedRecordIds();
+  }
+  /** @internal */
+  _onTableFieldsChanged(table, key, updates) {
+    if (!this._sorts) {
+      // If we don't have any sorts, we don't have to do anything in response to field changes.
+      return;
+    }
+    const {
+      addedFieldIds,
+      removedFieldIds
+    } = updates;
+    const fieldIdsSet = new Set(this._sorts.map(sort => sort.fieldId));
+
+    // Check if any fields that we rely on were created or deleted. If they were,
+    // replace our vis list.
+    // NOTE: we need to check for created, since a field that we rely on can be
+    // deleted and then undeleted.
+    let wereAnyFieldsCreatedOrDeleted = false;
+    for (const fieldId of addedFieldIds) {
+      // If a field that we rely on was created (i.e. it was undeleted), we need to
+      // make sure we're watching it's config.
+      if (fieldIdsSet.has(fieldId)) {
+        wereAnyFieldsCreatedOrDeleted = true;
+        const field = this._table.getFieldByIdIfExists(fieldId);
+        (0, _error_utils.invariant)(field, 'Created field does not exist');
+        field.watch('type', this._onFieldConfigChanged, this);
+        field.watch('options', this._onFieldConfigChanged, this);
+      }
+    }
+
+    // coverage analysis
+    // istanbul ignore else
+    if (!wereAnyFieldsCreatedOrDeleted) {
+      wereAnyFieldsCreatedOrDeleted = removedFieldIds.some(fieldId => fieldIdsSet.has(fieldId));
+    }
+    if (wereAnyFieldsCreatedOrDeleted) {
+      // One of the fields we're relying on was deleted,
+      this._replaceVisList();
+      this._orderedRecordIds = this._generateOrderedRecordIds();
+
+      // Make sure we fire onChange events since the order may have changed
+      // as a result.
+      const changeData = {
+        addedRecordIds: [],
+        removedRecordIds: []
+      };
+      this._onChange(_record_query_result.default.WatchableKeys.records, changeData);
+      this._onChange(_record_query_result.default.WatchableKeys.recordIds, changeData);
+
+      // We do not unload/reload groupQueryResults if it's field is deleted as
+      // it is responsible for failing to load if the field doesn't exist
+    }
+  }
+  /** @internal */
+  _onCellValuesChanged(table, key, updates) {
+    if (!updates) {
+      // If there are no updates, do nothing, since we'll handle the initial
+      // callback when the record set is loaded (and we don't want to fire
+      // a cellValues change twice with no data).
+      return;
+    }
+    this._onChange(_record_query_result.default.WatchableKeys.cellValues, updates);
+  }
+  /** @internal */
+  _onCellValuesInFieldChanged(table, key, recordIds, fieldId) {
+    if (!recordIds && !fieldId) {
+      // If there are no updates, do nothing, since we'll handle the initial
+      // callback when the record set is loaded (and we don't want to fire
+      // a cellValuesInField change twice with no data).
+      return;
+    }
+    this._onChange(key, recordIds, fieldId);
+  }
+  /** @internal */
+  _generateOrderedRecordIds() {
+    if (this._sorts) {
+      (0, _error_utils.invariant)(this._visList, 'Cannot generate record ids without a vis list');
+      return this._visList.getOrderedRecordIds();
+    } else {
+      return this._sourceModelRecordIds;
+    }
+  }
+  /** @internal */
+  _generateAndLoadOrderedGroups() {
+    // istanbul ignore next
+    if (this._groupLevels) {
+      (0, _error_utils.invariant)(this._visList, 'Cannot generate record ids without a vis list');
+      throw (0, _error_utils.spawnError)('custom group configs not supported');
+    } else {
+      // Get the group from the view itself
+      const groupLevels = this._sourceModelGroupLevels;
+      if (!this._sourceModelGroups || !groupLevels) {
+        return null;
+      }
+      return this._sourceModelGroups.map(groupData => {
+        const group = this.__groupedRecordQueryResultPool.getObjectForReuse(this, groupData, groupLevels, this._normalizedOpts, this._sdk);
+        // Don't await the loading, let others check isDataLoaded.
+        // (it doesn't take any time anyway). Loading also strong retains.
+        group.loadDataAsync();
+        return group;
+      });
+    }
+  }
+  /** @internal */
+  _unloadOrderedGroupsIfNeeded() {
+    if (this._orderedGroups) {
+      for (const group of this._orderedGroups) {
+        group.unloadData();
+      }
+    }
+  }
+  /**
+   * If groupings change then some groups will need to be created, and some removed
+   * This (TODO: will) handle the diffing necessary to unload, and reload only the changed groups.
+   * Also triggers the WatchableKeys.group, as by necessity this will have changed.
+   *
+   * @internal
+   */
+  // TODO: (SeanKeenan) Properly diff and only unload groups that need to be unloaded
+  // In the meantime it's not too expensive to just unload everything, and GroupedRecordQueryResults
+  // don't yet properly watch changes relevant to updating, so this isn't too bad.
+  // (They do invalidate their recordId caches, which is some very cheap work that we could remove)
+  _unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches() {
+    this._unloadOrderedGroupsIfNeeded();
+    this._orderedGroups = this._generateAndLoadOrderedGroups();
+    this._onChange(_record_query_result.default.WatchableKeys.groups);
+  }
+  /** @internal */
+  _replaceVisList() {
+    const airtableInterface = this._sdk.__airtableInterface;
+    const appInterface = this._sdk.__appInterface;
+    const recordDatas = this._sourceModelRecords.map(record => record._data);
+    const fieldDatas = this._table.fields.map(field => field._data);
+    const filteredSorts = this._getSortsWithDeletedFieldsFiltered();
+    this._visList = airtableInterface.createVisList(appInterface, recordDatas, fieldDatas, filteredSorts);
+  }
+  /** @internal */
+  _getSortsWithDeletedFieldsFiltered() {
+    (0, _error_utils.invariant)(this._sorts, 'No sorts');
+
+    // Filter out any sorts levels that rely on deleted fields.
+    // NOTE: we keep deleted fields around (rather than filtering them out
+    // in realtime) in case a field gets undeleted, in which case we want to
+    // keep using it.
+    return this._sorts.filter(sort => {
+      const field = this._table.getFieldByIdIfExists(sort.fieldId);
+      return !!field;
+    });
+  }
+  /** @internal */
+  _spawnErrorForDeletion() {
+    const sourceModelName = this._sourceModel instanceof _table.default ? 'table' : 'view';
+    return (0, _error_utils.spawnError)("RecordQueryResult's underlying %s has been deleted", sourceModelName);
+  }
+}
+var _default = exports.default = TableOrViewQueryResult;