@baselift/blocks-testing 0.0.1

package/dist/cjs/mock_airtable_interface.js

@@ -0,0 +1,851 @@
+"use strict";
+
+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");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+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 _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"));
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.object.values.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _unstable_testing_utils = require("@baselift/blocks/unstable_testing_utils");
+var _test_mutations = require("./test_mutations");
+var _private_utils = require("./private_utils");
+var _error_utils = require("./error_utils");
+var _excluded = ["opts"];
+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 _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+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 MutationTypeValues = Object.freeze(Object.values(_unstable_testing_utils.MutationTypes));
+var unmodifiableSdkData = {
+  isDevelopmentMode: false,
+  blockInstallationId: 'bliTESTING',
+  isFirstRun: false,
+  isFullscreen: false,
+  intentData: null
+};
+var unmodifiableBaseData = {
+  enabledFeatureNames: [],
+  billingPlanGrouping: 'pro',
+  permissionLevel: 'create',
+  appInterface: {},
+  isBlockDevelopmentRestrictionEnabled: false
+};
+var unmodifiableTableData = {
+  lock: null,
+  externalSyncById: null
+};
+var unmodifiableFieldData = {
+  lock: null,
+  isSynced: false
+};
+
+/**
+ * Prior to version 4.1, TypeScript's built-in type guard for the native
+ * `Array.isArray` did not function correctly for values of type
+ * `ReadonlyArray`. This helper provides the expected functionality for the
+ * purposes of `setGlobalConfigValue`.
+ * TODO: replace with `Array.isArray` in TypeScript 4.1 or later.
+ *
+ * @internal
+ */
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
+
+/**
+ * Determine whether a given Mutation is defined by the Blocks SDK (and used in
+ * production scenarios) or defined by the blocks-testing library (and used
+ * purely for simulation purposes).
+ *
+ * @internal
+ */
+function isAuthenticMutation(mutation) {
+  return MutationTypeValues.includes(mutation.type);
+}
+var alphanumerics = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+/**
+ * Select a random element from an array-like object.
+ *
+ * @internal
+ */
+function pick(arraylike) {
+  return arraylike[Math.floor(Math.random() * arraylike.length)];
+}
+
+/** @internal */
+
+function setGlobalConfigValue(target, path, value) {
+  if (isReadonlyArray(target)) {
+    var _newTarget = target.slice();
+    var index = parseInt(path[0], 10);
+    if (path.length === 1) {
+      if (value === undefined) {
+        _newTarget.splice(index, 1);
+      } else {
+        _newTarget[index] = value;
+      }
+    } else {
+      _newTarget[index] = setGlobalConfigValue(target[index] || {}, path.slice(1), value);
+    }
+    return _newTarget;
+  }
+  var newTarget = typeof target === 'object' ? _objectSpread({}, target) : {};
+  if (path.length === 1) {
+    if (value === undefined) {
+      delete newTarget[path[0]];
+    } else {
+      newTarget[path[0]] = value;
+    }
+  } else {
+    newTarget[path[0]] = setGlobalConfigValue(newTarget[path[0]] || {}, path.slice(1), value);
+  }
+  return newTarget;
+}
+
+/**
+ * A mapping relating the names of event subscriptions available on
+ * {@link TestDriver} instances to the arguments that are provided when one of
+ * those events is triggered.
+ */
+
+/**
+ * A complete set of information necessary to initialize a simulated Airtable
+ * Base in automated test environments.
+ */
+
+/** A representation of the state of a Table */
+
+/** A representation of the state of a Field */
+
+/** A representation of the state of a View */
+
+/**
+ * A reference to Record contained within a simulated view. This is distinct
+ * from the complete fixture data for the simulated Record.
+ */
+
+/** A representation of the state of a Record */
+
+/** @hidden */
+
+/**
+ * A callback function allowing tests to simulate user interaction with the
+ * expanded record picker UI. The testing library will invoke this function
+ * whenever the Extension under test uses the {@link expandRecordPickerAsync}
+ * function, and the return value of this function will be provided to the Extension
+ * under test as the {@link Record} that the simulated user selected.
+ */
+
+var generateGenericId = () => {
+  var length = 10 + Math.floor(Math.random() * 10);
+  return Array.from({
+    length
+  }).map(() => pick(alphanumerics)).join('');
+};
+
+/**
+ * An implementation of the MockAirtableInterface designed for use in automated
+ * test suites for Airtable Blocks maintained externally. Provides a more
+ * high-level constructor for specifying test fixture data and implements some
+ * features which approximate interactions with Hyperbase in production.
+ *
+ * @hidden
+ */
+var MockAirtableInterface = exports.default = /*#__PURE__*/function (_AbstractMockAirtable) {
+  function MockAirtableInterface(unsafeFixtureData) {
+    var _this;
+    (0, _classCallCheck2.default)(this, MockAirtableInterface);
+    var fixtureData = (0, _private_utils.cloneDeep)(unsafeFixtureData);
+    var store = {
+      tables: {},
+      views: {}
+    };
+    if (!fixtureData.base.tables || !fixtureData.base.tables.length) {
+      throw (0, _error_utils.spawnError)('Fixture data must include at least one table');
+    }
+    var tables = fixtureData.base.tables.map(table => {
+      if (table.id in store.tables) {
+        throw (0, _error_utils.spawnError)('repeated table ID: %s', table.id);
+      }
+      store.tables[table.id] = (0, _private_utils.keyBy)(table.records, _private_utils.getId);
+      store.views[table.id] = {};
+      if (!table.fields || !table.fields.length) {
+        throw (0, _error_utils.spawnError)('Every table in fixture data must specify at least one field, but table "%s" specified zero fields', table.id);
+      }
+      table.fields.map(_ref => {
+        var id = _ref.id;
+        return id;
+      }).forEach((id, index, ids) => {
+        if (ids.indexOf(id) !== index) {
+          throw (0, _error_utils.spawnError)('repeated field ID: %s', id);
+        }
+      });
+      if (!table.views || !table.views.length) {
+        throw (0, _error_utils.spawnError)('Every table in fixture data must specify at least one view, but table "%s" specified zero views', table.id);
+      }
+      var _iterator = _createForOfIteratorHelper(table.views),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var view = _step.value;
+          if (view.id in store.views[table.id]) {
+            throw (0, _error_utils.spawnError)('repeated view ID: %s', view.id);
+          }
+          var _iterator2 = _createForOfIteratorHelper(view.records),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var record = _step2.value;
+              if (!(record.id in store.tables[table.id])) {
+                throw (0, _error_utils.spawnError)('record %s not present in table %s', record.id, table.id);
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+          store.views[table.id][view.id] = {
+            fieldOrder: view.fieldOrder,
+            records: view.records
+          };
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return _objectSpread(_objectSpread({}, unmodifiableTableData), {}, {
+        id: table.id,
+        name: table.name,
+        description: table.description,
+        fieldsById: (0, _private_utils.keyBy)(table.fields.map(field => _objectSpread(_objectSpread({}, field), {}, {
+          typeOptions: field.options
+        }, unmodifiableFieldData)), _private_utils.getId),
+        primaryFieldId: table.fields[0].id,
+        viewsById: (0, _private_utils.keyBy)(table.views, _private_utils.getId),
+        activeViewId: table.views[0].id,
+        viewOrder: table.views.map(_ref2 => {
+          var id = _ref2.id;
+          return id;
+        })
+      });
+    });
+    var sdkInitData = _objectSpread(_objectSpread({}, unmodifiableSdkData), {}, {
+      initialKvValuesByKey: fixtureData.globalConfig || {},
+      baseData: _objectSpread(_objectSpread({}, unmodifiableBaseData), {}, {
+        id: fixtureData.base.id,
+        name: fixtureData.base.name,
+        color: fixtureData.base.color || 'gray',
+        activeTableId: tables[0].id,
+        tableOrder: tables.map(_ref3 => {
+          var id = _ref3.id;
+          return id;
+        }),
+        tablesById: (0, _private_utils.keyBy)(tables, _private_utils.getId),
+        currentUserId: fixtureData.base.collaborators[0].id,
+        cursorData: {
+          selectedRecordIdSet: {},
+          selectedFieldIdSet: {}
+        },
+        collaboratorsById: (0, _private_utils.keyBy)(fixtureData.base.collaborators, _private_utils.getId),
+        activeCollaboratorIds: fixtureData.base.collaborators.filter(_ref4 => {
+          var isActive = _ref4.isActive;
+          return isActive;
+        }).map(_ref5 => {
+          var id = _ref5.id;
+          return id;
+        }),
+        workspaceId: fixtureData.base.workspaceId
+      }),
+      runContext: {
+        type: _unstable_testing_utils.BlockRunContextType.DASHBOARD_APP
+      }
+    });
+    _this = _callSuper(this, MockAirtableInterface, [sdkInitData]);
+    (0, _defineProperty2.default)(_this, "_recordDataStore", void 0);
+    (0, _defineProperty2.default)(_this, "_userPermissionCheck", void 0);
+    (0, _defineProperty2.default)(_this, "_pickRecord", void 0);
+    _this._recordDataStore = store;
+    return _this;
+  }
+  (0, _inherits2.default)(MockAirtableInterface, _AbstractMockAirtable);
+  return (0, _createClass2.default)(MockAirtableInterface, [{
+    key: "applyMutationAsync",
+    value: function () {
+      var _applyMutationAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(mutation, opts) {
+        var tableData, viewUpdates, fieldData, viewData, _tableData, newOrder, updates, _internalOpts, mainMutation;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (mutation.type === _test_mutations.TestMutationTypes.DELETE_SINGLE_FIELD) {
+                tableData = this.sdkInitData.baseData.tablesById[mutation.tableId];
+                (0, _error_utils.invariant)(tableData.primaryFieldId !== mutation.id, "A table's primary field may not be deleted.");
+                viewUpdates = Object.values(tableData.viewsById).filter(view => {
+                  return view.fieldOrder && view.fieldOrder.fieldIds.includes(mutation.id);
+                }).map(view => {
+                  var fieldOrder = view.fieldOrder;
+                  (0, _error_utils.invariant)(fieldOrder, 'View must define a field ordering');
+                  var index = fieldOrder.fieldIds.indexOf(mutation.id);
+                  var fieldIds = fieldOrder.fieldIds.slice();
+                  fieldIds.splice(index, 1);
+                  var visibleFieldCount = index < fieldOrder.visibleFieldCount ? fieldOrder.visibleFieldCount - 1 : fieldOrder.visibleFieldCount;
+                  return {
+                    path: ['tablesById', mutation.tableId, 'viewsById', view.id, 'fieldOrder'],
+                    value: {
+                      fieldIds,
+                      visibleFieldCount
+                    }
+                  };
+                });
+                viewUpdates.forEach(_ref6 => {
+                  var path = _ref6.path,
+                    value = _ref6.value;
+                  var view = this._recordDataStore.views[path[1]][path[3]];
+                  (0, _error_utils.invariant)(view, 'Internal update must reference existing view');
+                  view.fieldOrder = value;
+                });
+                this.triggerModelUpdates([{
+                  path: ['tablesById', mutation.tableId, 'fieldsById', mutation.id],
+                  value: undefined
+                }, ...viewUpdates]);
+              } else if (mutation.type === _test_mutations.TestMutationTypes.CREATE_SINGLE_TABLE) {
+                fieldData = mutation.fields.map(field => {
+                  return _objectSpread({
+                    id: this.idGenerator.generateFieldId(),
+                    name: field.name,
+                    description: '',
+                    type: field.config.type,
+                    typeOptions: field.config.options
+                  }, unmodifiableFieldData);
+                });
+                viewData = {
+                  id: generateGenericId(),
+                  name: 'Dynamically-generated Grid view',
+                  type: _unstable_testing_utils.ViewType.GRID,
+                  fieldOrder: {
+                    fieldIds: fieldData.map(_ref7 => {
+                      var id = _ref7.id;
+                      return id;
+                    }),
+                    visibleFieldCount: fieldData.length
+                  }
+                };
+                this.triggerModelUpdates([{
+                  path: ['tablesById', mutation.id],
+                  value: _objectSpread({
+                    id: mutation.id,
+                    name: mutation.name,
+                    primaryFieldId: fieldData[0].id,
+                    viewOrder: [viewData.id],
+                    viewsById: {
+                      [viewData.id]: viewData
+                    },
+                    fieldsById: (0, _private_utils.keyBy)(fieldData, _private_utils.getId)
+                  }, unmodifiableTableData)
+                }, {
+                  path: ['tableOrder'],
+                  value: this.sdkInitData.baseData.tableOrder.concat(mutation.id)
+                }]);
+                this._recordDataStore.tables[mutation.id] = {};
+                this._recordDataStore.views[mutation.id] = {
+                  [viewData.id]: {
+                    fieldOrder: viewData.fieldOrder,
+                    records: []
+                  }
+                };
+              } else if (mutation.type === _test_mutations.TestMutationTypes.CREATE_MULTIPLE_RECORDS) {
+                Object.assign(this._recordDataStore.tables[mutation.tableId], (0, _private_utils.keyBy)(mutation.records, _private_utils.getId));
+              } else if (mutation.type === _test_mutations.TestMutationTypes.DELETE_SINGLE_VIEW) {
+                _tableData = this.sdkInitData.baseData.tablesById[mutation.tableId];
+                (0, _error_utils.invariant)(_tableData.viewOrder.length > 1, 'The view in a table with one view may not be deleted');
+                newOrder = _tableData.viewOrder.filter(id => id !== mutation.id);
+                delete this._recordDataStore.views[mutation.id];
+                updates = [{
+                  path: ['tablesById', mutation.tableId, 'viewOrder'],
+                  value: newOrder
+                }, {
+                  path: ['tablesById', mutation.tableId, 'viewsById', mutation.id],
+                  value: undefined
+                }];
+                if (mutation.id === this.sdkInitData.baseData.tablesById[mutation.tableId].activeViewId) {
+                  updates.push({
+                    path: ['tablesById', mutation.tableId, 'activeViewId'],
+                    value: newOrder[0]
+                  });
+                }
+                this.triggerModelUpdates(updates);
+              }
+              if (!isAuthenticMutation(mutation)) {
+                _context.next = 2;
+                break;
+              }
+              if (!(mutation.type === _test_mutations.TestMutationTypes.CREATE_MULTIPLE_RECORDS || mutation.type === _test_mutations.TestMutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES)) {
+                _context.next = 1;
+                break;
+              }
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              _internalOpts = mutation.opts, mainMutation = (0, _objectWithoutProperties2.default)(mutation, _excluded);
+              this.emit('mutation', mainMutation);
+              return _context.abrupt("return");
+            case 1:
+              this.emit('mutation', mutation);
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function applyMutationAsync(_x, _x2) {
+        return _applyMutationAsync.apply(this, arguments);
+      }
+      return applyMutationAsync;
+    }()
+  }, {
+    key: "checkPermissionsForMutation",
+    value: function checkPermissionsForMutation(mutation) {
+      if (!this._userPermissionCheck || this._userPermissionCheck(mutation)) {
+        return {
+          hasPermission: true
+        };
+      }
+      return {
+        hasPermission: false,
+        reasonDisplayString: 'The testing environment has been configured to deny this mutation.'
+      };
+    }
+  }, {
+    key: "globalConfigHelpers",
+    get: function get() {
+      var globalConfigHelpers = _superPropGet(MockAirtableInterface, "globalConfigHelpers", this, 1);
+      globalConfigHelpers.validateAndApplyUpdates = (updates, store) => {
+        var changedTopLevelKeys = new Set();
+        var newKvStore = _objectSpread({}, store);
+        var _iterator3 = _createForOfIteratorHelper(updates),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var update = _step3.value;
+            changedTopLevelKeys.add(update.path[0]);
+            newKvStore = setGlobalConfigValue(newKvStore, update.path, update.value);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        return {
+          newKvStore,
+          changedTopLevelKeys: Array.from(changedTopLevelKeys)
+        };
+      };
+      return globalConfigHelpers;
+    }
+  }, {
+    key: "emit",
+    value: function emit(key, data) {
+      _superPropGet(MockAirtableInterface, "emit", this, 3)([key, data]);
+    }
+  }, {
+    key: "expandRecord",
+    value: function expandRecord(tableId, recordId, recordIds) {
+      this.emit('expandRecord', {
+        recordId,
+        recordIds
+      });
+    }
+  }, {
+    key: "expandRecordList",
+    value: function expandRecordList(tableId, recordIds, fieldIds) {
+      this.emit('expandRecordList', {
+        tableId,
+        recordIds,
+        fieldIds
+      });
+    }
+  }, {
+    key: "expandRecordPickerAsync",
+    value: function () {
+      var _expandRecordPickerAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(tableId, recordIds, fieldIds, shouldAllowCreatingRecord) {
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (this._pickRecord) {
+                _context2.next = 1;
+                break;
+              }
+              throw (0, _error_utils.spawnError)('Unable to simulate user record selection for `expandRecordPickerAsync`. The test environment must be configured with the record to select before this method is called.');
+            case 1:
+              return _context2.abrupt("return", this._pickRecord(tableId, recordIds, fieldIds, shouldAllowCreatingRecord));
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function expandRecordPickerAsync(_x3, _x4, _x5, _x6) {
+        return _expandRecordPickerAsync.apply(this, arguments);
+      }
+      return expandRecordPickerAsync;
+    }()
+  }, {
+    key: "fieldTypeProvider",
+    get: function get() {
+      var fieldTypeProvider = _superPropGet(MockAirtableInterface, "fieldTypeProvider", this, 1);
+      fieldTypeProvider.convertCellValueToString = (appInterface, cellValue, fieldData) => {
+        if (cellValue === null) {
+          return '';
+        }
+        if (Array.isArray(cellValue)) {
+          return cellValue.map(item => {
+            return fieldTypeProvider.convertCellValueToString(appInterface, item, fieldData);
+          }).join(', ');
+        }
+        if (typeof cellValue === 'object' && cellValue !== null && (0, _private_utils.has)(cellValue, 'name')) {
+          var named = cellValue;
+          if (typeof named.name === 'string') {
+            return named.name;
+          }
+        }
+        return String(cellValue);
+      };
+      return fieldTypeProvider;
+    }
+  }, {
+    key: "fetchAndSubscribeToCellValuesInFieldsAsync",
+    value: function () {
+      var _fetchAndSubscribeToCellValuesInFieldsAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(tableId, fieldIds) {
+        var _iterator4, _step4, _fieldId, recordsById, _i, _Object$values, record, cellValuesByFieldId, _iterator5, _step5, fieldId, _t;
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (tableId in this._recordDataStore.tables) {
+                _context3.next = 1;
+                break;
+              }
+              throw (0, _error_utils.spawnError)('table not present in fixture data: %s', tableId);
+            case 1:
+              _iterator4 = _createForOfIteratorHelper(fieldIds);
+              _context3.prev = 2;
+              _iterator4.s();
+            case 3:
+              if ((_step4 = _iterator4.n()).done) {
+                _context3.next = 5;
+                break;
+              }
+              _fieldId = _step4.value;
+              if (_fieldId in this.sdkInitData.baseData.tablesById[tableId].fieldsById) {
+                _context3.next = 4;
+                break;
+              }
+              throw (0, _error_utils.spawnError)('field %s not present in table %s', _fieldId, tableId);
+            case 4:
+              _context3.next = 3;
+              break;
+            case 5:
+              _context3.next = 7;
+              break;
+            case 6:
+              _context3.prev = 6;
+              _t = _context3["catch"](2);
+              _iterator4.e(_t);
+            case 7:
+              _context3.prev = 7;
+              _iterator4.f();
+              return _context3.finish(7);
+            case 8:
+              recordsById = {};
+              for (_i = 0, _Object$values = Object.values(this._recordDataStore.tables[tableId]); _i < _Object$values.length; _i++) {
+                record = _Object$values[_i];
+                cellValuesByFieldId = {};
+                _iterator5 = _createForOfIteratorHelper(fieldIds);
+                try {
+                  for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                    fieldId = _step5.value;
+                    cellValuesByFieldId[fieldId] = record.cellValuesByFieldId[fieldId];
+                  }
+                } catch (err) {
+                  _iterator5.e(err);
+                } finally {
+                  _iterator5.f();
+                }
+                recordsById[record.id] = _objectSpread(_objectSpread({}, record), {}, {
+                  cellValuesByFieldId
+                });
+              }
+              return _context3.abrupt("return", {
+                recordsById
+              });
+            case 9:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[2, 6, 7, 8]]);
+      }));
+      function fetchAndSubscribeToCellValuesInFieldsAsync(_x7, _x8) {
+        return _fetchAndSubscribeToCellValuesInFieldsAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToCellValuesInFieldsAsync;
+    }()
+  }, {
+    key: "fetchAndSubscribeToCursorDataAsync",
+    value: function () {
+      var _fetchAndSubscribeToCursorDataAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+        var cursorData, selectedRecordIdSet;
+        return _regenerator.default.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              cursorData = this.sdkInitData.baseData.cursorData;
+              selectedRecordIdSet = Object.assign({}, cursorData && cursorData.selectedRecordIdSet);
+              return _context4.abrupt("return", {
+                selectedRecordIdSet,
+                selectedFieldIdSet: {}
+              });
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function fetchAndSubscribeToCursorDataAsync() {
+        return _fetchAndSubscribeToCursorDataAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToCursorDataAsync;
+    }()
+  }, {
+    key: "fetchAndSubscribeToTableDataAsync",
+    value: function () {
+      var _fetchAndSubscribeToTableDataAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(tableId) {
+        return _regenerator.default.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              if (tableId in this._recordDataStore.tables) {
+                _context5.next = 1;
+                break;
+              }
+              throw (0, _error_utils.spawnError)('table not present in fixture data: %s', tableId);
+            case 1:
+              return _context5.abrupt("return", {
+                recordsById: this._recordDataStore.tables[tableId]
+              });
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function fetchAndSubscribeToTableDataAsync(_x9) {
+        return _fetchAndSubscribeToTableDataAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToTableDataAsync;
+    }()
+  }, {
+    key: "fetchAndSubscribeToViewDataAsync",
+    value: function () {
+      var _fetchAndSubscribeToViewDataAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(tableId, viewId) {
+        var tableSchema, viewData;
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              if (tableId in this.sdkInitData.baseData.tablesById) {
+                _context6.next = 1;
+                break;
+              }
+              throw (0, _error_utils.spawnError)('table not present in fixture data: %s', tableId);
+            case 1:
+              tableSchema = this.sdkInitData.baseData.tablesById[tableId];
+              if (viewId in tableSchema.viewsById) {
+                _context6.next = 2;
+                break;
+              }
+              throw (0, _error_utils.spawnError)('view not present in fixture data: %s', viewId);
+            case 2:
+              viewData = this._recordDataStore.views[tableId][viewId];
+              return _context6.abrupt("return", {
+                visibleRecordIds: viewData.records.map(_ref8 => {
+                  var id = _ref8.id;
+                  return id;
+                }),
+                fieldOrder: viewData.fieldOrder,
+                colorsByRecordId: {}
+              });
+            case 3:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function fetchAndSubscribeToViewDataAsync(_x0, _x1) {
+        return _fetchAndSubscribeToViewDataAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToViewDataAsync;
+    }()
+  }, {
+    key: "hasRecord",
+    value: function hasRecord(tableId, recordId) {
+      var recordsById = this._recordDataStore.tables[tableId];
+      return recordsById && recordId in recordsById;
+    }
+  }, {
+    key: "idGenerator",
+    get: function get() {
+      var idGenerator = _superPropGet(MockAirtableInterface, "idGenerator", this, 1);
+      idGenerator.generateRecordId = generateGenericId;
+      idGenerator.generateFieldId = generateGenericId;
+      return idGenerator;
+    }
+  }, {
+    key: "on",
+    value: function on(key, fn) {
+      _superPropGet(MockAirtableInterface, "on", this, 3)([key, fn]);
+    }
+  }, {
+    key: "off",
+    value: function off(key, fn) {
+      _superPropGet(MockAirtableInterface, "off", this, 3)([key, fn]);
+    }
+  }, {
+    key: "setFullscreenMaxSize",
+    value: function setFullscreenMaxSize(maxFullscreenSize) {
+      this.emit('setFullscreenMaxSize', maxFullscreenSize);
+    }
+  }, {
+    key: "setPickRecord",
+    value: function setPickRecord(pickRecord) {
+      this._pickRecord = pickRecord;
+    }
+  }, {
+    key: "setUserPermissionCheck",
+    value: function setUserPermissionCheck(check) {
+      this._userPermissionCheck = check;
+    }
+  }, {
+    key: "performBackendFetchAsync",
+    value: function () {
+      var _performBackendFetchAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7(requestJson) {
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)('Backend fetch is not currently supported in the blocks testing environment.');
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function performBackendFetchAsync(_x10) {
+        return _performBackendFetchAsync.apply(this, arguments);
+      }
+      return performBackendFetchAsync;
+    }()
+  }, {
+    key: "fetchDefaultCellValuesByFieldIdAsync",
+    value: function () {
+      var _fetchDefaultCellValuesByFieldIdAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        return _regenerator.default.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return", {});
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function fetchDefaultCellValuesByFieldIdAsync() {
+        return _fetchDefaultCellValuesByFieldIdAsync.apply(this, arguments);
+      }
+      return fetchDefaultCellValuesByFieldIdAsync;
+    }()
+  }, {
+    key: "reloadFrame",
+    value: function reloadFrame() {}
+  }, {
+    key: "setSettingsButtonVisibility",
+    value: function setSettingsButtonVisibility() {}
+  }, {
+    key: "setUndoRedoMode",
+    value: function setUndoRedoMode() {}
+  }, {
+    key: "enterFullscreen",
+    value: function enterFullscreen() {
+      this.emit('enterFullscreen', null);
+    }
+  }, {
+    key: "exitFullscreen",
+    value: function exitFullscreen() {
+      this.emit('exitFullscreen', null);
+    }
+  }, {
+    key: "fetchAndSubscribeToPerformRecordActionAsync",
+    value: function () {
+      var _fetchAndSubscribeToPerformRecordActionAsync = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+        return _regenerator.default.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              return _context9.abrupt("return", null);
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function fetchAndSubscribeToPerformRecordActionAsync() {
+        return _fetchAndSubscribeToPerformRecordActionAsync.apply(this, arguments);
+      }
+      return fetchAndSubscribeToPerformRecordActionAsync;
+    }()
+  }, {
+    key: "trackEvent",
+    value: function trackEvent() {}
+
+    /**
+     * `trackExposure` cannot be invoked by any Extensions (neither those authored by
+     * Airtable nor by other Extension developers). It should be implemented to
+     * satisfy the AirtableInterface contract, but the implementation should
+     * not throw because it must be successful for Extensions to function. Likewise,
+     * it should not emit an event because test authors have no need to track
+     * its usage.
+     */
+  }, {
+    key: "trackExposure",
+    value: function trackExposure() {}
+  }, {
+    key: "sendStat",
+    value: function sendStat() {}
+  }]);
+}(_unstable_testing_utils.AbstractMockAirtableInterface);