@airtable/blocks 1.3.0 → 1.5.1

package/CHANGELOG.md

@@ -9,10 +9,39 @@ Not every commit needs to result in a change to this file (e.g. docs and chore c
 commit that affects the code in a way that consumers might care about should include edits to the
 'Unreleased' section though. Breaking changes should be prefixed with `**BREAKING:**`.
 
-## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.3.0...HEAD)
+## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.5.1...HEAD)
 
 No changes.
 
+## [1.5.1](https://github.com/airtable/blocks/compare/@airtable/blocks@1.5.0...@airtable/blocks@1.5.1) - 2021-03-04
+
+No changes.
+
+## [1.5.0](https://github.com/airtable/blocks/compare/@airtable/blocks@1.4.1...@airtable/blocks@1.5.0) - 2021-02-25
+
+-   Add type exports for `Cursor` & `Session` to `@airtable/blocks/models`.
+-   Add type exports for `GlobalConfig`, `Watchable`, & `Viewport` to `@airtable/blocks/types`.
+-   Add `boltList`, `boltListMicro`, `contacts`, `contactsMicro`, `megaphone`, `megaphoneMicro`,
+    `shareWithBolt` and `shareWithBoltMicro` icons.
+-   Increase spacing between `label` and `description` nodes in `FormField`.
+-   Support creating (but not updating) `MULTIPLE_RECORD_LINKS` fields using
+    `table.createFieldAsync`.
+-   Add `isCancelButtonDisabled` and `isConfirmButtonDisabled` props to `ConfirmationDialog`.
+-   Add `config` property to `Field`, which is a new `FieldConfig` discriminated union type that
+    provides easier access to field options.
+-   Improve type definitions for `getHexForColor` and `getRgbForColor`.
+
+## [1.4.1](https://github.com/airtable/blocks/compare/@airtable/blocks@1.4.0...@airtable/blocks@1.4.1) - 2021-01-21
+
+No changes.
+
+## [1.4.0](https://github.com/airtable/blocks/compare/@airtable/blocks@1.3.0...@airtable/blocks@1.4.0) - 2021-01-19
+
+-   **DEPRECATED:** importing the Base's Cursor instance from the main entrypoint, e.g.
+    `import {cursor} from '@airtable/blocks';`. Use the `useCursor` React Hook instead.
+-   **DEPRECATED:** importing the Base's Session instance from the main entrypoint, e.g.
+    `import {session} from '@airtable/blocks';`. Use the `useSession` React Hook instead.
+
 ## [1.3.0](https://github.com/airtable/blocks/compare/@airtable/blocks@1.2.5...@airtable/blocks@1.3.0) - 2021-01-07
 
 -   Fix crash when deleting views.

package/dist/cjs/index.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.__reset = __reset;
-exports.unstable_fetchAsync = exports.viewport = exports.undoRedo = exports.settingsButton = exports.session = exports.runInfo = exports.reload = exports.installationId = exports.globalConfig = exports.cursor = exports.base = exports.__sdk = void 0;
+exports.session = exports.cursor = exports.unstable_fetchAsync = exports.viewport = exports.undoRedo = exports.settingsButton = exports.runInfo = exports.reload = exports.installationId = exports.globalConfig = exports.base = exports.__sdk = void 0;
 
 var _perform_record_action = require("./perform_record_action");
 
@@ -20,8 +20,6 @@ var _sdk2 = _interopRequireDefault(require("./sdk"));
 
 var _create_aggregators = require("./models/create_aggregators");
 
-var _expand_record_picker_async = require("./ui/expand_record_picker_async");
-
 var _initialize_block = require("./ui/initialize_block");
 
 /** @internal */
@@ -30,8 +28,6 @@ var __sdk;
 exports.__sdk = __sdk;
 var base;
 exports.base = base;
-var cursor;
-exports.cursor = cursor;
 var globalConfig;
 exports.globalConfig = globalConfig;
 var installationId;
@@ -40,16 +36,42 @@ var reload;
 exports.reload = reload;
 var runInfo;
 exports.runInfo = runInfo;
-var session;
-exports.session = session;
 var settingsButton;
 exports.settingsButton = settingsButton;
 var undoRedo;
 exports.undoRedo = undoRedo;
 var viewport;
 exports.viewport = viewport;
-var unstable_fetchAsync;
+var unstable_fetchAsync; // The `cursor` binding is declared on the following line solely as a signal to
+// the TypeScript compiler. The exported value is actually controlled by the
+// subsequent CommonJS module property descriptor.
+
 exports.unstable_fetchAsync = unstable_fetchAsync;
+var cursor;
+exports.cursor = cursor;
+Object.defineProperty(module.exports, 'cursor', {
+  enumerable: true,
+
+  get() {
+    (0, _warning.default)('`import {cursor} from "@airtable/blocks"` is deprecated. Use `import {useCursor} from "@airtable/blocks/ui"` instead.');
+    return __sdk.cursor;
+  }
+
+}); // The `session` binding is declared on the following line solely as a signal
+// to the TypeScript compiler. The exported value is actually controlled by the
+// subsequent CommonJS module property descriptor.
+
+var session;
+exports.session = session;
+Object.defineProperty(module.exports, 'session', {
+  enumerable: true,
+
+  get() {
+    (0, _warning.default)('`import {session} from "@airtable/blocks"` is deprecated. Use `import {useSession} from "@airtable/blocks/ui"` instead.');
+    return __sdk.session;
+  }
+
+});
 Object.defineProperty(module.exports, 'UI', {
   enumerable: true,
 
@@ -74,12 +96,10 @@ function __reset() {
   exports.__sdk = __sdk = new _sdk2.default((0, _airtable_interface.default)());
   var _sdk = __sdk;
   exports.base = base = _sdk.base;
-  exports.cursor = cursor = _sdk.cursor;
   exports.globalConfig = globalConfig = _sdk.globalConfig;
   exports.installationId = installationId = _sdk.installationId;
   exports.reload = reload = _sdk.reload;
   exports.runInfo = runInfo = _sdk.runInfo;
-  exports.session = session = _sdk.session;
   exports.settingsButton = settingsButton = _sdk.settingsButton;
   exports.undoRedo = undoRedo = _sdk.undoRedo;
   exports.viewport = viewport = _sdk.viewport;
@@ -89,7 +109,6 @@ function __reset() {
   // the module dependency graph.
   (0, _create_aggregators.__injectSdkIntoCreateAggregators)(__sdk);
   (0, _perform_record_action.__injectSdkIntoPerformRecordAction)(__sdk);
-  (0, _expand_record_picker_async.__injectSdkIntoExpandRecordPickerAsync)(__sdk);
   (0, _initialize_block.__injectSdkIntoInitializeBlock)(__sdk);
   (0, _warning.__injectSdkIntoWarning)(__sdk);
 }

package/dist/cjs/injected/airtable_interface.js

@@ -9,6 +9,7 @@ var _error_utils = require("../error_utils");
 
 var AIRTABLE_INTERFACE_VERSION = 0;
 var airtableInterface = null;
+var missingAirtableInterfaceErrorMessage = ['Error: App environment misconfigured', '\n\n', 'Airtable Apps can only run in the presence of an Airtable Base. If you ', 'are trying to run your App with a Base hosted on airtable.com, then be ', 'sure you are using the Airtable CLI to serve your code and accessing it ', 'through a Custom App installed inside a Base on airtable.com.', '\n\n', 'If you are trying to run automated tests for your App, then make sure ', 'you have loaded the `@airtable/testing-library` module *before* the ', '`@airtable/blocks` module.'].join('');
 /** @hidden */
 
 function getAirtableInterface() {
@@ -16,7 +17,7 @@ function getAirtableInterface() {
 
   if (!airtableInterface) {
     if (!getAirtableInterfaceAtVersion) {
-      throw (0, _error_utils.spawnError)('@airtable/blocks can only run inside the block frame');
+      throw (0, _error_utils.spawnError)(missingAirtableInterfaceErrorMessage);
     }
 
     airtableInterface = getAirtableInterfaceAtVersion(AIRTABLE_INTERFACE_VERSION);

package/dist/cjs/models/cursor.js

@@ -81,12 +81,10 @@ var WatchableCursorKeys = Object.freeze({
  * {@link useLoadable} to access them.
  *
  * ```js
- * import {cursor} from '@airtable/blocks';
- * import {useWatchable} from '@airtable/blocks/ui';
+ * import {useCursor, useWatchable} from '@airtable/blocks/ui';
  *
  *  function ActiveTableAndView() {
- *      // re-render whenever the active table or view changes
- *      useWatchable(cursor, ['activeTableId', 'activeViewId']);
+ *      const cursor = useCursor();
  *
  *      return (
  *          <div>
@@ -98,10 +96,10 @@ var WatchableCursorKeys = Object.freeze({
  * ```
  *
  * ```js
- * import {cursor} from '@airtable/blocks';
- * import {useLoadable, useWatchable} from '@airtable/blocks/ui';
+ * import {useCursor, useLoadable, useWatchable} from '@airtable/blocks/ui';
  *
  *  function SelectedRecordAndFieldIds() {
+ *      const cursor = useCursor();
  *      // load selected records and fields
  *      useLoadable(cursor);
  *

package/dist/cjs/models/field.js

@@ -444,6 +444,30 @@ function (_AbstractModel) {
 
       return options ? (0, _private_utils.cloneDeep)(options) : null;
     }
+    /**
+     * The type and options of the field to make type narrowing `FieldOptions` easier.
+     *
+     * @see {@link FieldConfig}
+     * @example
+     * const fieldConfig = field.config;
+     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
+     *     return fieldConfig.options.choices;
+     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
+     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
+     *         return fieldConfig.options.result.options.choices;
+     *     }
+     * }
+     * return DEFAULT_CHOICES;
+     */
+
+  }, {
+    key: "config",
+    get: function get() {
+      return {
+        type: this.type,
+        options: this.options
+      };
+    }
   }, {
     key: "isComputed",
     get: function get() {

package/dist/cjs/models/grouped_record_query_result.js

@@ -0,0 +1,475 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.concat");
+
+require("core-js/modules/es.array.iterator");
+
+require("core-js/modules/es.array.map");
+
+require("core-js/modules/es.array.slice");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+require("regenerator-runtime/runtime");
+
+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 _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error_utils = require("../error_utils");
+
+var _record_query_result = _interopRequireDefault(require("./record_query_result"));
+
+var _object_pool = _interopRequireDefault(require("./object_pool"));
+
+/** @module @airtable/blocks/models: RecordQueryResult */
+
+/** */
+
+/**
+ * Represents a group of records returned from a group query. See {@link RecordQueryResult} for main
+ * documentation.
+ *
+ * Do not instantiate. You can get instances of this class by calling
+ * `recordQueryResult.groups`.
+ *
+ * @docsPath models/query results/GroupedRecordQueryResult
+ * @hidden
+ */
+var GroupedRecordQueryResult =
+/*#__PURE__*/
+function (_RecordQueryResult) {
+  (0, _inherits2.default)(GroupedRecordQueryResult, _RecordQueryResult);
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * This includes groupLevel for all children & parent grouped layers, the getter
+   * returns only the groupLevels for this layer.
+   *
+   * @internal
+   */
+  // This is the ordered list of groups.
+
+  /** @internal */
+  // lazily generated set of record ids
+
+  /** @internal */
+  // lazily generated ordered array of recordIds
+
+  /** @internal */
+
+  /** @internal */
+  function GroupedRecordQueryResult(parentQueryResult, groupData, groupLevel, normalizedOpts, sdk) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, GroupedRecordQueryResult);
+    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(GroupedRecordQueryResult).call(this, sdk, normalizedOpts));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentQueryResult", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_groupData", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_groupLevels", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_orderedChildrenGroups", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_recordIdsSet", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_orderedRecordIds", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "__groupedRecordQueryResultPool", void 0);
+    _this.__groupedRecordQueryResultPool = new _object_pool.default(GroupedRecordQueryResult);
+    _this._parentQueryResult = parentQueryResult;
+    _this._groupData = groupData;
+    _this._groupLevels = groupLevel;
+
+    var groupLevelDataSlicedForChildren = _this._groupLevels.slice(1);
+
+    _this._orderedChildrenGroups = groupData.groups ? groupData.groups.map(singleGroupData => {
+      var group = _this.__groupedRecordQueryResultPool.getObjectForReuse((0, _assertThisInitialized2.default)(_this), singleGroupData, groupLevelDataSlicedForChildren, normalizedOpts, 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;
+    }) : null;
+    return _this;
+  }
+  /**
+   * Gets children groups of this group (if any exist)
+   */
+
+
+  (0, _createClass2.default)(GroupedRecordQueryResult, [{
+    key: "_computeRecordIds",
+
+    /**
+     * Recursively gets all recordIds in the children groups, keeping recordIds in group order
+     *
+     * @internal
+     */
+    value: function _computeRecordIds() {
+      // If we are a leaf node, return the raw recordIds
+      if (!this.groups) {
+        var _this$_data$groupData;
+
+        // Typescript can't infer if groups is empty visibleRecordIds must be populated
+        // but the extra safety isn't bad. (istanbul also can't ignore just the ??)
+        // istanbul ignore next
+        return (_this$_data$groupData = this._data.groupData.visibleRecordIds) !== null && _this$_data$groupData !== void 0 ? _this$_data$groupData : [];
+      } // Otherwise build the recordId's from children groups
+
+
+      var recordIds = [];
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = this.groups[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var group = _step.value;
+          recordIds.push(...group.recordIds);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      return recordIds;
+    }
+    /**
+     * Anytime the recordIds to return could have changed, we clear this so that
+     * the next time the user requests recordIds it recomputes
+     *
+     * @internal
+     */
+
+  }, {
+    key: "_invalidateComputedRecordIds",
+    value: function _invalidateComputedRecordIds() {
+      this._orderedRecordIds = null;
+    }
+    /**
+     * Ordered array of all the record ids inside this group, in group order.
+     * This returns all recordIds of all children groups (in grouped order).
+     * Watchable.
+     */
+
+  }, {
+    key: "watch",
+
+    /** @inheritdoc */
+    value: function watch(keys, callback, context) {
+      // TODO (SeanKeenan): This provides events even if they occur outside of this group
+      // This is an issue that needs to be fixed before this API is made public
+      var validKeys = this._parentQueryResult.watch(keys, callback, context);
+
+      return validKeys;
+    }
+    /** @inheritdoc */
+
+  }, {
+    key: "unwatch",
+    value: function unwatch(keys, callback, context) {
+      return this._parentQueryResult.unwatch(keys, callback, context);
+    }
+    /** @inheritdoc */
+
+  }, {
+    key: "loadDataAsync",
+    value: function loadDataAsync() {
+      return _regenerator.default.async(function loadDataAsync$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return _regenerator.default.awrap((0, _get2.default)((0, _getPrototypeOf2.default)(GroupedRecordQueryResult.prototype), "loadDataAsync", this).call(this));
+
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, null, this);
+    }
+    /** @internal */
+
+  }, {
+    key: "_getChangedKeysOnLoad",
+    value: function _getChangedKeysOnLoad() {
+      return this._parentQueryResult._getChangedKeysOnLoad();
+    }
+    /** @internal */
+
+  }, {
+    key: "_loadDataAsync",
+    value: function _loadDataAsync() {
+      return _regenerator.default.async(function _loadDataAsync$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this); // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
+              // TODO: (SeanKeenan) At the moment this should never be relevant, because groups are recreated
+              // anytime the groups change - but this is how it should work once groups persist AND
+              // watching recordIds only changes if records in this group change.
+              // In the meantime this does ensure that a deleted GroupedRecordQuery with stale recordIds
+              // doesn't return the cached array.
+
+
+              this.watch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
+              this.watch(['recordIds'], this._invalidateRecordIdsSet, this);
+              return _context2.abrupt("return", this._getChangedKeysOnLoad());
+
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    }
+    /** @internal */
+
+  }, {
+    key: "_unloadData",
+    value: function _unloadData() {
+      // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
+      this.unwatch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
+      this.unwatch(['recordIds'], this._invalidateRecordIdsSet, this); // Invalidate both of the caches, as this object can no longer be accessed
+
+      this._invalidateComputedRecordIds();
+
+      this._invalidateRecordIdsSet();
+
+      this._unloadChildrenGroupsIfNeeded();
+
+      this._parentQueryResult.__groupedRecordQueryResultPool.unregisterObjectForReuseStrong(this);
+    }
+    /** @internal */
+
+  }, {
+    key: "_unloadChildrenGroupsIfNeeded",
+
+    /** @internal */
+    value: function _unloadChildrenGroupsIfNeeded() {
+      if (this._orderedChildrenGroups) {
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = this._orderedChildrenGroups[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var group = _step2.value;
+            group.unloadData();
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+      }
+    }
+    /** @internal */
+
+  }, {
+    key: "_invalidateRecordIdsSet",
+    value: function _invalidateRecordIdsSet() {
+      this._recordIdsSet = null;
+    }
+    /** @internal */
+
+  }, {
+    key: "_getOrGenerateRecordIdsSet",
+    value: function _getOrGenerateRecordIdsSet() {
+      // TODO (SeanKeenan): this logic is duplicated in tableOrViewQueryResult
+      if (!this._recordIdsSet) {
+        var recordIdsSet = {};
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
+
+        try {
+          for (var _iterator3 = this.recordIds[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            var recordId = _step3.value;
+            recordIdsSet[recordId] = true;
+          }
+        } catch (err) {
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+              _iterator3.return();
+            }
+          } finally {
+            if (_didIteratorError3) {
+              throw _iteratorError3;
+            }
+          }
+        }
+
+        this._recordIdsSet = recordIdsSet;
+      }
+
+      return this._recordIdsSet;
+    }
+  }, {
+    key: "groups",
+    get: function get() {
+      return this._orderedChildrenGroups;
+    }
+    /** @internal */
+
+  }, {
+    key: "groupLevel",
+    get: function get() {
+      return this._data.groupLevels[0];
+    }
+    /**
+     * Gets the fieldId that this group is grouped by
+     */
+
+  }, {
+    key: "fieldId",
+    get: function get() {
+      return this.groupLevel.fieldId;
+    }
+    /**
+     * Gets the field that this group is grouped by
+     */
+
+  }, {
+    key: "field",
+    get: function get() {
+      return this.parentTable.getFieldById(this.fieldId);
+    } // TODO (SeanKeenan) This is needed because we can't always iterate down and find
+    // a record, it's possible to have "empty groups".
+    // getValue() {
+    // }
+    // TODO (SeanKeenan)
+    // getValueAsString() {
+    // }
+
+    /**
+     * @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
+     */
+
+  }, {
+    key: "parentTable",
+    get: function get() {
+      return this._parentQueryResult.parentTable;
+    }
+  }, {
+    key: "recordIds",
+    get: function get() {
+      (0, _error_utils.invariant)(this.isDataLoaded, 'GroupedRecordQueryResult data is not loaded');
+
+      if (this._orderedRecordIds === null) {
+        this._orderedRecordIds = this._computeRecordIds();
+      }
+
+      return this._orderedRecordIds;
+    }
+    /**
+     * The fields that were used to create the parent RecordQueryResult that created this GroupedRecordQueryResult.
+     * This is separate from the field/fieldId property - which is the field this grouping is based upon.
+     * Null if fields were not specified, which means the RecordQueryResult
+     * will load all fields in the table.
+     */
+
+  }, {
+    key: "fields",
+    get: function get() {
+      (0, _error_utils.invariant)(this.isDataLoaded, 'GroupedRecordQueryResult data is not loaded');
+      return this._parentQueryResult.fields;
+    }
+  }, {
+    key: "__poolKey",
+    get: function get() {
+      // TODO (SeanKeenan) We don't have an actual groupId, but while id is unique; this should have id removed
+      return "".concat(this._serializedOpts, "::").concat(this.id);
+    }
+    /**
+     * This model doesn't actually load data, but it does use the `_data`
+     * property so that checks for model deletion behave appropriately.
+     *
+     * This is considered deleted if the parent query result has been deleted.
+     *
+     * We return groupData, instead of precomputing all children groups because
+     * we perform the computation+caching lazily on request
+     *
+     * @internal
+     */
+
+  }, {
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      if (this._parentQueryResult._dataOrNullIfDeleted === null) {
+        return null;
+      }
+
+      return {
+        groupData: this._groupData,
+        groupLevels: this._groupLevels
+      };
+    }
+    /** @inheritdoc */
+
+  }, {
+    key: "isDataLoaded",
+    get: function get() {
+      return this._parentQueryResult.isDataLoaded;
+    }
+  }]);
+  return GroupedRecordQueryResult;
+}(_record_query_result.default);
+
+(0, _defineProperty2.default)(GroupedRecordQueryResult, "_className", 'GroupedRecordQueryResult');
+var _default = GroupedRecordQueryResult;
+exports.default = _default;