@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-75d011284-20250904

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

@@ -1,35 +1,9 @@
 "use strict";
 
-require("core-js/modules/es.symbol.js");
-require("core-js/modules/es.symbol.description.js");
-require("core-js/modules/es.array.filter.js");
-require("core-js/modules/es.array.from.js");
-require("core-js/modules/es.array.iterator.js");
-require("core-js/modules/es.array.slice.js");
-require("core-js/modules/es.object.get-own-property-descriptors.js");
-require("core-js/modules/es.regexp.exec.js");
-require("core-js/modules/es.regexp.to-string.js");
-require("core-js/modules/web.dom-collections.iterator.js");
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.WatchableTableKeys = void 0;
-require("core-js/modules/es.array.find.js");
-require("core-js/modules/es.array.includes.js");
-require("core-js/modules/es.object.to-string.js");
-require("core-js/modules/es.string.includes.js");
-require("core-js/modules/web.dom-collections.for-each.js");
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _table_core = require("../../shared/models/table_core");
 var _error_utils = require("../../shared/error_utils");
 var _private_utils = require("../../shared/private_utils");
@@ -39,18 +13,15 @@ var _field = _interopRequireDefault(require("./field"));
 var _table_or_view_query_result = _interopRequireDefault(require("./table_or_view_query_result"));
 var _view = _interopRequireDefault(require("./view"));
 var _object_pool = _interopRequireDefault(require("./object_pool"));
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } /** @module @airtable/blocks/models: Table */ /** */
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module @airtable/blocks/models: Table */ /** */
+
 // This doesn't follow our enum naming conventions because we want the keys
 // to mirror the method/getter names on the model class.
-var WatchableTableKeys = exports.WatchableTableKeys = Object.freeze(_objectSpread(_objectSpread({}, _table_core.WatchableTableKeysCore), {}, {
+const WatchableTableKeys = exports.WatchableTableKeys = Object.freeze({
+  ..._table_core.WatchableTableKeysCore,
   views: 'views'
-}));
+});
 
 /**
  * A key in {@link Table} that can be watched.
@@ -59,610 +30,491 @@ var WatchableTableKeys = exports.WatchableTableKeys = Object.freeze(_objectSprea
  * - `fields`
  * - `views`
  */
+
 /**
  * Model class representing a table. Every {@link Base} has one or more tables.
  *
  * @docsPath models/Table
  */
-var Table = /*#__PURE__*/function (_TableCore) {
+class Table extends _table_core.TableCore {
+  /** @internal */
+  static _className = 'Table';
   /** @internal */
-  function Table(parentBase, recordStore, tableId, sdk) {
-    var _this;
-    (0, _classCallCheck2.default)(this, Table);
-    _this = _callSuper(this, Table, [parentBase, recordStore, tableId, sdk]);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "_viewModelsById", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "__tableOrViewQueryResultPool", void 0);
-    _this._viewModelsById = {}; // View instances are lazily created by getViewById.
-    _this.__tableOrViewQueryResultPool = new _object_pool.default(_table_or_view_query_result.default);
-    return _this;
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableTableKeys, key);
   }
+  /** @internal */
 
   /** @internal */
-  (0, _inherits2.default)(Table, _TableCore);
-  return (0, _createClass2.default)(Table, [{
-    key: "_constructField",
-    value: function _constructField(fieldId) {
-      return new _field.default(this.parentBase.__sdk, this, fieldId);
-    }
 
-    /**
-     * The URL for the table. You can visit this URL in the browser to be taken to the table in the Airtable UI.
-     *
-     * @example
-     * ```js
-     * console.log(myTable.url);
-     * // => 'https://airtable.com/appxxxxxxxxxxxxxx/tblxxxxxxxxxxxxxx'
-     * ```
-     */
-  }, {
-    key: "url",
-    get: function get() {
-      return this._sdk.__airtableInterface.urlConstructor.getTableUrl(this.id);
-    }
+  /** @internal */
+  constructor(parentBase, recordStore, tableId, sdk) {
+    super(parentBase, recordStore, tableId, sdk);
+    this._viewModelsById = {}; // View instances are lazily created by getViewById.
+    this.__tableOrViewQueryResultPool = new _object_pool.default(_table_or_view_query_result.default);
+  }
 
-    // Experimental, do not document yet. Allows fetching default cell values for
-    // a table or view. Before documenting, we should explore making this synchronous.
-    /**
-     * @internal
-     */
-    // istanbul ignore next
-  }, {
-    key: "getDefaultCellValuesByFieldIdAsync",
-    value: function () {
-      var _getDefaultCellValuesByFieldIdAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(opts) {
-        var viewId, cellValuesByFieldId;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              viewId = opts && opts.view ? opts.view.id : null;
-              _context.next = 3;
-              return this._sdk.__airtableInterface.fetchDefaultCellValuesByFieldIdAsync(this._id, viewId);
-            case 3:
-              cellValuesByFieldId = _context.sent;
-              return _context.abrupt("return", cellValuesByFieldId);
-            case 5:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function getDefaultCellValuesByFieldIdAsync(_x) {
-        return _getDefaultCellValuesByFieldIdAsync.apply(this, arguments);
+  /** @internal */
+  _constructField(fieldId) {
+    return new _field.default(this.parentBase.__sdk, this, fieldId);
+  }
+
+  /**
+   * The URL for the table. You can visit this URL in the browser to be taken to the table in the Airtable UI.
+   *
+   * @example
+   * ```js
+   * console.log(myTable.url);
+   * // => 'https://airtable.com/appxxxxxxxxxxxxxx/tblxxxxxxxxxxxxxx'
+   * ```
+   */
+  get url() {
+    return this._sdk.__airtableInterface.urlConstructor.getTableUrl(this.id);
+  }
+
+  // Experimental, do not document yet. Allows fetching default cell values for
+  // a table or view. Before documenting, we should explore making this synchronous.
+  /**
+   * @internal
+   */
+  // istanbul ignore next
+  async getDefaultCellValuesByFieldIdAsync(opts) {
+    const viewId = opts && opts.view ? opts.view.id : null;
+    const cellValuesByFieldId = await this._sdk.__airtableInterface.fetchDefaultCellValuesByFieldIdAsync(this._id, viewId);
+    return cellValuesByFieldId;
+  }
+
+  /**
+   * The views in this table. Can be watched to know when views are created,
+   * deleted, or reordered.
+   *
+   * @example
+   * ```js
+   * console.log(`This table has ${myTable.views.length} views`);
+   * ```
+   */
+  get views() {
+    // TODO(kasra): cache and freeze this so it isn't O(n)
+    const views = [];
+    this._data.viewOrder.forEach(viewId => {
+      const view = this.getViewById(viewId);
+      views.push(view);
+    });
+    return views;
+  }
+  /**
+   * Gets the view matching the given ID, or `null` if that view does not exist in this table.
+   *
+   * @param viewId The ID of the view.
+   * @example
+   * ```js
+   * const viewId = 'viwxxxxxxxxxxxxxx';
+   * const view = myTable.getViewByIdIfExists(viewId);
+   * if (view !== null) {
+   *     console.log(view.name);
+   * } else {
+   *     console.log('No view exists with that ID');
+   * }
+   * ```
+   */
+  getViewByIdIfExists(viewId) {
+    if (!this._data.viewsById[viewId]) {
+      return null;
+    } else {
+      if (!this._viewModelsById[viewId]) {
+        this._viewModelsById[viewId] = new _view.default(this._sdk, this, this._recordStore.getViewDataStore(viewId), viewId);
       }
-      return getDefaultCellValuesByFieldIdAsync;
-    }()
-    /**
-     * The views in this table. Can be watched to know when views are created,
-     * deleted, or reordered.
-     *
-     * @example
-     * ```js
-     * console.log(`This table has ${myTable.views.length} views`);
-     * ```
-     */
-  }, {
-    key: "views",
-    get: function get() {
-      // TODO(kasra): cache and freeze this so it isn't O(n)
-      var views = [];
-      this._data.viewOrder.forEach(viewId => {
-        var view = this.getViewById(viewId);
-        views.push(view);
-      });
-      return views;
+      return this._viewModelsById[viewId];
     }
-    /**
-     * Gets the view matching the given ID, or `null` if that view does not exist in this table.
-     *
-     * @param viewId The ID of the view.
-     * @example
-     * ```js
-     * const viewId = 'viwxxxxxxxxxxxxxx';
-     * const view = myTable.getViewByIdIfExists(viewId);
-     * if (view !== null) {
-     *     console.log(view.name);
-     * } else {
-     *     console.log('No view exists with that ID');
-     * }
-     * ```
-     */
-  }, {
-    key: "getViewByIdIfExists",
-    value: function getViewByIdIfExists(viewId) {
-      if (!this._data.viewsById[viewId]) {
-        return null;
-      } else {
-        if (!this._viewModelsById[viewId]) {
-          this._viewModelsById[viewId] = new _view.default(this._sdk, this, this._recordStore.getViewDataStore(viewId), viewId);
-        }
-        return this._viewModelsById[viewId];
-      }
+  }
+  /**
+   * Gets the view matching the given ID. Throws if that view does not exist in this table. Use
+   * {@link getViewByIdIfExists} instead if you are unsure whether a view exists with the given
+   * ID.
+   *
+   * @param viewId The ID of the view.
+   * @example
+   * ```js
+   * const viewId = 'viwxxxxxxxxxxxxxx';
+   * const view = myTable.getViewById(viewId);
+   * console.log(view.name);
+   * // => 'Grid view'
+   * ```
+   */
+  getViewById(viewId) {
+    const view = this.getViewByIdIfExists(viewId);
+    if (!view) {
+      throw (0, _error_utils.spawnError)("No view with ID %s in table '%s'", viewId, this.name);
     }
-    /**
-     * Gets the view matching the given ID. Throws if that view does not exist in this table. Use
-     * {@link getViewByIdIfExists} instead if you are unsure whether a view exists with the given
-     * ID.
-     *
-     * @param viewId The ID of the view.
-     * @example
-     * ```js
-     * const viewId = 'viwxxxxxxxxxxxxxx';
-     * const view = myTable.getViewById(viewId);
-     * console.log(view.name);
-     * // => 'Grid view'
-     * ```
-     */
-  }, {
-    key: "getViewById",
-    value: function getViewById(viewId) {
-      var view = this.getViewByIdIfExists(viewId);
-      if (!view) {
-        throw (0, _error_utils.spawnError)("No view with ID %s in table '%s'", viewId, this.name);
+    return view;
+  }
+  /**
+   * Gets the view matching the given name, or `null` if no view exists with that name in this
+   * table.
+   *
+   * @param viewName The name of the view you're looking for.
+   * @example
+   * ```js
+   * const view = myTable.getViewByNameIfExists('Name');
+   * if (view !== null) {
+   *     console.log(view.id);
+   * } else {
+   *     console.log('No view exists with that name');
+   * }
+   * ```
+   */
+  getViewByNameIfExists(viewName) {
+    for (const [viewId, viewData] of (0, _private_utils.entries)(this._data.viewsById)) {
+      if (viewData.name === viewName) {
+        return this.getViewByIdIfExists(viewId);
       }
-      return view;
     }
-    /**
-     * Gets the view matching the given name, or `null` if no view exists with that name in this
-     * table.
-     *
-     * @param viewName The name of the view you're looking for.
-     * @example
-     * ```js
-     * const view = myTable.getViewByNameIfExists('Name');
-     * if (view !== null) {
-     *     console.log(view.id);
-     * } else {
-     *     console.log('No view exists with that name');
-     * }
-     * ```
-     */
-  }, {
-    key: "getViewByNameIfExists",
-    value: function getViewByNameIfExists(viewName) {
-      var _iterator = _createForOfIteratorHelper((0, _private_utils.entries)(this._data.viewsById)),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
-            viewId = _step$value[0],
-            viewData = _step$value[1];
-          if (viewData.name === viewName) {
-            return this.getViewByIdIfExists(viewId);
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      return null;
+    return null;
+  }
+  /**
+   * Gets the view matching the given name. Throws if no view exists with that name in this table.
+   * Use {@link getViewByNameIfExists} instead if you are unsure whether a view exists with the
+   * given name.
+   *
+   * @param viewName The name of the view you're looking for.
+   * @example
+   * ```js
+   * const view = myTable.getViewByName('Name');
+   * console.log(view.id);
+   * // => 'viwxxxxxxxxxxxxxx'
+   * ```
+   */
+  getViewByName(viewName) {
+    const view = this.getViewByNameIfExists(viewName);
+    if (!view) {
+      throw (0, _error_utils.spawnError)("No view named '%s' in table '%s'", viewName, this.name);
     }
-    /**
-     * Gets the view matching the given name. Throws if no view exists with that name in this table.
-     * Use {@link getViewByNameIfExists} instead if you are unsure whether a view exists with the
-     * given name.
-     *
-     * @param viewName The name of the view you're looking for.
-     * @example
-     * ```js
-     * const view = myTable.getViewByName('Name');
-     * console.log(view.id);
-     * // => 'viwxxxxxxxxxxxxxx'
-     * ```
-     */
-  }, {
-    key: "getViewByName",
-    value: function getViewByName(viewName) {
-      var view = this.getViewByNameIfExists(viewName);
-      if (!view) {
-        throw (0, _error_utils.spawnError)("No view named '%s' in table '%s'", viewName, this.name);
-      }
-      return view;
+    return view;
+  }
+  /**
+   * The view matching the given ID or name. Returns `null` if no matching view exists within
+   * this table.
+   *
+   * This method is convenient when building an extension for a specific base, but for more generic
+   * extensions the best practice is to use the {@link getViewByIdIfExists} or
+   * {@link getViewByNameIfExists} methods instead.
+   *
+   * @param viewIdOrName The ID or name of the view you're looking for.
+   */
+  getViewIfExists(viewIdOrName) {
+    return this.getViewByIdIfExists(viewIdOrName) ?? this.getViewByNameIfExists(viewIdOrName);
+  }
+  /**
+   * The view matching the given ID or name. Throws if no matching view exists within this table.
+   * Use {@link getViewIfExists} instead if you are unsure whether a view exists with the given
+   * name/ID.
+   *
+   * This method is convenient when building an extension for a specific base, but for more generic
+   * extensions the best practice is to use the {@link getViewById} or {@link getViewByName} methods
+   * instead.
+   *
+   * @param viewIdOrName The ID or name of the view you're looking for.
+   */
+  getView(viewIdOrName) {
+    const view = this.getViewIfExists(viewIdOrName);
+    if (!view) {
+      throw (0, _error_utils.spawnError)("No view with ID or name '%s' in table '%s'", viewIdOrName, this.name);
     }
-    /**
-     * The view matching the given ID or name. Returns `null` if no matching view exists within
-     * this table.
-     *
-     * This method is convenient when building an extension for a specific base, but for more generic
-     * extensions the best practice is to use the {@link getViewByIdIfExists} or
-     * {@link getViewByNameIfExists} methods instead.
-     *
-     * @param viewIdOrName The ID or name of the view you're looking for.
-     */
-  }, {
-    key: "getViewIfExists",
-    value: function getViewIfExists(viewIdOrName) {
-      var _this$getViewByIdIfEx;
-      return (_this$getViewByIdIfEx = this.getViewByIdIfExists(viewIdOrName)) !== null && _this$getViewByIdIfEx !== void 0 ? _this$getViewByIdIfEx : this.getViewByNameIfExists(viewIdOrName);
+    return view;
+  }
+  /**
+   * Select records from the table. Returns a {@link RecordQueryResult}.
+   *
+   * Consider using {@link useRecords} or {@link useRecordIds} instead, unless you need the
+   * features of a QueryResult (e.g. `queryResult.getRecordById`). Record hooks handle
+   * loading/unloading and updating your UI automatically, but manually `select`ing records is
+   * useful for one-off data processing.
+   *
+   * @param opts Options for the query, such as sorts and fields.
+   * @example
+   * ```js
+   * import {useBase, useRecords} from '@airtable/blocks/base/ui';
+   * import React from 'react';
+   *
+   * function TodoList() {
+   *     const base = useBase();
+   *     const table = base.getTableByName('Tasks');
+   *
+   *     const queryResult = table.selectRecords();
+   *     const records = useRecords(queryResult);
+   *
+   *     return (
+   *         <ul>
+   *             {records.map(record => (
+   *                 <li key={record.id}>
+   *                     {record.name || 'Unnamed record'}
+   *                 </li>
+   *             ))}
+   *         </ul>
+   *     );
+   * }
+   * ```
+   */
+  selectRecords(opts) {
+    const normalizedOpts = _record_query_result.default._normalizeOpts(this, this._recordStore, opts || {});
+    return this.__tableOrViewQueryResultPool.getObjectForReuse(this._sdk, this, normalizedOpts);
+  }
+  /**
+   * Select and load records from the table. Returns a {@link RecordQueryResult} promise where
+   * record data has been loaded.
+   *
+   * Consider using {@link useRecords} or {@link useRecordIds} instead, unless you need the
+   * features of a QueryResult (e.g. `queryResult.getRecordById`). Record hooks handle
+   * loading/unloading and updating your UI automatically, but manually `select`ing records is
+   * useful for one-off data processing.
+   *
+   * Once you've finished with your query, remember to call `queryResult.unloadData()`.
+   *
+   * @param opts Options for the query, such as sorts and fields.
+   * @example
+   * ```js
+   * async function logRecordCountAsync(table) {
+   *     const query = await table.selectRecordsAsync();
+   *     console.log(query.recordIds.length);
+   *     query.unloadData();
+   * }
+   * ```
+   */
+  async selectRecordsAsync(opts) {
+    const queryResult = this.selectRecords(opts);
+    await queryResult.loadDataAsync();
+    return queryResult;
+  }
+  /**
+   * Returns the first view in the table where the type is one of `allowedViewTypes`, or `null` if
+   * no such view exists in the table.
+   *
+   * @param allowedViewTypes An array of view types or a single view type to match against.
+   * @param preferredViewOrViewId If a view or view ID is supplied and that view exists & has the
+   * correct type, that view will be returned before checking the other views in the table.
+   * @example
+   * ```js
+   * import {ViewType} from '@airtable/blocks/base/models';
+   * const firstCalendarView = myTable.getFirstViewOfType(ViewType.CALENDAR);
+   * if (firstCalendarView !== null) {
+   *     console.log(firstCalendarView.name);
+   * } else {
+   *     console.log('No calendar views exist in the table');
+   * }
+   * ```
+   */
+  getFirstViewOfType(allowedViewTypes, preferredViewOrViewId) {
+    if (!Array.isArray(allowedViewTypes)) {
+      allowedViewTypes = (0, _private_utils.cast)([allowedViewTypes]);
     }
-    /**
-     * The view matching the given ID or name. Throws if no matching view exists within this table.
-     * Use {@link getViewIfExists} instead if you are unsure whether a view exists with the given
-     * name/ID.
-     *
-     * This method is convenient when building an extension for a specific base, but for more generic
-     * extensions the best practice is to use the {@link getViewById} or {@link getViewByName} methods
-     * instead.
-     *
-     * @param viewIdOrName The ID or name of the view you're looking for.
-     */
-  }, {
-    key: "getView",
-    value: function getView(viewIdOrName) {
-      var view = this.getViewIfExists(viewIdOrName);
-      if (!view) {
-        throw (0, _error_utils.spawnError)("No view with ID or name '%s' in table '%s'", viewIdOrName, this.name);
+    if (preferredViewOrViewId) {
+      const preferredView = this.getViewByIdIfExists(typeof preferredViewOrViewId === 'string' ? preferredViewOrViewId : preferredViewOrViewId.id);
+      if (preferredView && allowedViewTypes.includes(preferredView.type)) {
+        return preferredView;
       }
-      return view;
     }
-    /**
-     * Select records from the table. Returns a {@link RecordQueryResult}.
-     *
-     * Consider using {@link useRecords} or {@link useRecordIds} instead, unless you need the
-     * features of a QueryResult (e.g. `queryResult.getRecordById`). Record hooks handle
-     * loading/unloading and updating your UI automatically, but manually `select`ing records is
-     * useful for one-off data processing.
-     *
-     * @param opts Options for the query, such as sorts and fields.
-     * @example
-     * ```js
-     * import {useBase, useRecords} from '@airtable/blocks/base/ui';
-     * import React from 'react';
-     *
-     * function TodoList() {
-     *     const base = useBase();
-     *     const table = base.getTableByName('Tasks');
-     *
-     *     const queryResult = table.selectRecords();
-     *     const records = useRecords(queryResult);
-     *
-     *     return (
-     *         <ul>
-     *             {records.map(record => (
-     *                 <li key={record.id}>
-     *                     {record.name || 'Unnamed record'}
-     *                 </li>
-     *             ))}
-     *         </ul>
-     *     );
-     * }
-     * ```
-     */
-  }, {
-    key: "selectRecords",
-    value: function selectRecords(opts) {
-      var normalizedOpts = _record_query_result.default._normalizeOpts(this, this._recordStore, opts || {});
-      return this.__tableOrViewQueryResultPool.getObjectForReuse(this._sdk, this, normalizedOpts);
-    }
-    /**
-     * Select and load records from the table. Returns a {@link RecordQueryResult} promise where
-     * record data has been loaded.
-     *
-     * Consider using {@link useRecords} or {@link useRecordIds} instead, unless you need the
-     * features of a QueryResult (e.g. `queryResult.getRecordById`). Record hooks handle
-     * loading/unloading and updating your UI automatically, but manually `select`ing records is
-     * useful for one-off data processing.
-     *
-     * Once you've finished with your query, remember to call `queryResult.unloadData()`.
-     *
-     * @param opts Options for the query, such as sorts and fields.
-     * @example
-     * ```js
-     * async function logRecordCountAsync(table) {
-     *     const query = await table.selectRecordsAsync();
-     *     console.log(query.recordIds.length);
-     *     query.unloadData();
-     * }
-     * ```
-     */
-  }, {
-    key: "selectRecordsAsync",
-    value: (function () {
-      var _selectRecordsAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(opts) {
-        var queryResult;
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              queryResult = this.selectRecords(opts);
-              _context2.next = 3;
-              return queryResult.loadDataAsync();
-            case 3:
-              return _context2.abrupt("return", queryResult);
-            case 4:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function selectRecordsAsync(_x2) {
-        return _selectRecordsAsync.apply(this, arguments);
+    return this.views.find(view => {
+      return allowedViewTypes.includes(view.type);
+    }) ?? null;
+  }
+  /**
+   * @internal
+   */
+  __getViewMatching(viewOrViewIdOrViewName) {
+    let view;
+    if (viewOrViewIdOrViewName instanceof _view.default) {
+      if (viewOrViewIdOrViewName.parentTable.id !== this.id) {
+        throw (0, _error_utils.spawnError)("View '%s' is from a different table than table '%s'", viewOrViewIdOrViewName.name, this.name);
       }
-      return selectRecordsAsync;
-    }()
-    /**
-     * Returns the first view in the table where the type is one of `allowedViewTypes`, or `null` if
-     * no such view exists in the table.
-     *
-     * @param allowedViewTypes An array of view types or a single view type to match against.
-     * @param preferredViewOrViewId If a view or view ID is supplied and that view exists & has the
-     * correct type, that view will be returned before checking the other views in the table.
-     * @example
-     * ```js
-     * import {ViewType} from '@airtable/blocks/base/models';
-     * const firstCalendarView = myTable.getFirstViewOfType(ViewType.CALENDAR);
-     * if (firstCalendarView !== null) {
-     *     console.log(firstCalendarView.name);
-     * } else {
-     *     console.log('No calendar views exist in the table');
-     * }
-     * ```
-     */
-    )
-  }, {
-    key: "getFirstViewOfType",
-    value: function getFirstViewOfType(allowedViewTypes, preferredViewOrViewId) {
-      var _this$views$find;
-      if (!Array.isArray(allowedViewTypes)) {
-        allowedViewTypes = (0, _private_utils.cast)([allowedViewTypes]);
+      view = viewOrViewIdOrViewName;
+    } else {
+      view = this.getViewByIdIfExists(viewOrViewIdOrViewName) || this.getViewByNameIfExists(viewOrViewIdOrViewName);
+      if (view === null) {
+        throw (0, _error_utils.spawnError)("View '%s' does not exist in table '%s'", viewOrViewIdOrViewName, this.name);
       }
-      if (preferredViewOrViewId) {
-        var preferredView = this.getViewByIdIfExists(typeof preferredViewOrViewId === 'string' ? preferredViewOrViewId : preferredViewOrViewId.id);
-        if (preferredView && allowedViewTypes.includes(preferredView.type)) {
-          return preferredView;
-        }
-      }
-      return (_this$views$find = this.views.find(view => {
-        return allowedViewTypes.includes(view.type);
-      })) !== null && _this$views$find !== void 0 ? _this$views$find : null;
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "__getViewMatching",
-    value: function __getViewMatching(viewOrViewIdOrViewName) {
-      var view;
-      if (viewOrViewIdOrViewName instanceof _view.default) {
-        if (viewOrViewIdOrViewName.parentTable.id !== this.id) {
-          throw (0, _error_utils.spawnError)("View '%s' is from a different table than table '%s'", viewOrViewIdOrViewName.name, this.name);
-        }
-        view = viewOrViewIdOrViewName;
-      } else {
-        view = this.getViewByIdIfExists(viewOrViewIdOrViewName) || this.getViewByNameIfExists(viewOrViewIdOrViewName);
-        if (view === null) {
-          throw (0, _error_utils.spawnError)("View '%s' does not exist in table '%s'", viewOrViewIdOrViewName, this.name);
-        }
-      }
-      if (view.isDeleted) {
-        throw (0, _error_utils.spawnError)("View '%s' was deleted from table '%s'", view.name, this.name);
-      }
-      return view;
+    if (view.isDeleted) {
+      throw (0, _error_utils.spawnError)("View '%s' was deleted from table '%s'", view.name, this.name);
     }
+    return view;
+  }
 
-    /**
-     * Checks whether the current user has permission to create a field in this table.
-     *
-     * Accepts partial input, in the same format as {@link createFieldAsync}.
-     *
-     * Returns `{hasPermission: true}` if the current user can update the specified record,
-     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
-     * used to display an error message to the user.
-     *
-     * @param name name for the field. must be case-insensitive unique for the table
-     * @param type type for the field
-     * @param options options for the field. omit for fields without writable options
-     * @param description description for the field. omit to leave blank
-     *
-     * @example
-     * ```js
-     * const createFieldCheckResult = table.checkPermissionsForCreateField();
-     *
-     * if (!createFieldCheckResult.hasPermission) {
-     *     alert(createFieldCheckResult.reasonDisplayString);
-     * }
-     * ```
-     */
-  }, {
-    key: "checkPermissionsForCreateField",
-    value: function checkPermissionsForCreateField(name, type, options, description) {
-      return this._sdk.__mutations.checkPermissionsForMutation({
-        type: _mutations.MutationTypes.CREATE_SINGLE_FIELD,
-        tableId: this.id,
-        id: undefined,
-        // Generated in createFieldAsync.
-        name,
-        config: type ? _objectSpread({
-          type: type
-        }, options ? {
+  /**
+   * Checks whether the current user has permission to create a field in this table.
+   *
+   * Accepts partial input, in the same format as {@link createFieldAsync}.
+   *
+   * Returns `{hasPermission: true}` if the current user can update the specified record,
+   * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+   * used to display an error message to the user.
+   *
+   * @param name name for the field. must be case-insensitive unique for the table
+   * @param type type for the field
+   * @param options options for the field. omit for fields without writable options
+   * @param description description for the field. omit to leave blank
+   *
+   * @example
+   * ```js
+   * const createFieldCheckResult = table.checkPermissionsForCreateField();
+   *
+   * if (!createFieldCheckResult.hasPermission) {
+   *     alert(createFieldCheckResult.reasonDisplayString);
+   * }
+   * ```
+   */
+  checkPermissionsForCreateField(name, type, options, description) {
+    return this._sdk.__mutations.checkPermissionsForMutation({
+      type: _mutations.MutationTypes.CREATE_SINGLE_FIELD,
+      tableId: this.id,
+      id: undefined,
+      // Generated in createFieldAsync.
+      name,
+      config: type ? {
+        type: type,
+        // In field.options we translate options to null when it's undefined (no options),
+        // but the mutation expects config to match the PublicApiConfig, where it's
+        // not present at all (options: undefined will fail validation).
+        ...(options ? {
           options
-        } : null) : undefined,
-        description
-      });
-    }
+        } : null)
+      } : undefined,
+      description
+    });
+  }
 
-    /**
-     * An alias for `checkPermissionsForCreateField(name, type, options, description).hasPermission`.
-     *
-     * Checks whether the current user has permission to create a field in this table.
-     *
-     * Accepts partial input, in the same format as {@link createFieldAsync}.
-     *
-     * @param name name for the field. must be case-insensitive unique for the table
-     * @param type type for the field
-     * @param options options for the field. omit for fields without writable options
-     * @param description description for the field. omit to leave blank
-     *
-     * @example
-     * ```js
-     * const canCreateField = table.hasPermissionToCreateField();
-     *
-     * if (!canCreateField) {
-     *     alert('not allowed!');
-     * }
-     * ```
-     */
-  }, {
-    key: "hasPermissionToCreateField",
-    value: function hasPermissionToCreateField(name, type, options, description) {
-      return this.checkPermissionsForCreateField(name, type, options, description).hasPermission;
-    }
+  /**
+   * An alias for `checkPermissionsForCreateField(name, type, options, description).hasPermission`.
+   *
+   * Checks whether the current user has permission to create a field in this table.
+   *
+   * Accepts partial input, in the same format as {@link createFieldAsync}.
+   *
+   * @param name name for the field. must be case-insensitive unique for the table
+   * @param type type for the field
+   * @param options options for the field. omit for fields without writable options
+   * @param description description for the field. omit to leave blank
+   *
+   * @example
+   * ```js
+   * const canCreateField = table.hasPermissionToCreateField();
+   *
+   * if (!canCreateField) {
+   *     alert('not allowed!');
+   * }
+   * ```
+   */
+  hasPermissionToCreateField(name, type, options, description) {
+    return this.checkPermissionsForCreateField(name, type, options, description).hasPermission;
+  }
 
-    /**
-     * Creates a new field.
-     *
-     * Similar to creating a field from the Airtable UI, the new field will not be visible
-     * in views that have other hidden fields and views that are publicly shared.
-     *
-     * Throws an error if the user does not have permission to create a field, if invalid
-     * name, type or options are provided, or if creating fields of this type is not supported.
-     *
-     * Refer to {@link FieldType} for supported field types, the write format for options, and
-     * other specifics for certain field types.
-     *
-     * This action is asynchronous. Unlike new records, new fields are **not** created
-     * optimistically locally. You must `await` the returned promise before using the new
-     * field in your extension.
-     *
-     * @param name name for the field. must be case-insensitive unique
-     * @param type type for the field
-     * @param options options for the field. omit for fields without writable options
-     * @param description description for the field. is optional and will be `''` if not specified
-     * or if specified as `null`.
-     *
-     * @example
-     * ```js
-     * async function createNewSingleLineTextField(table, name) {
-     *     if (table.hasPermissionToCreateField(name, FieldType.SINGLE_LINE_TEXT)) {
-     *         await table.createFieldAsync(name, FieldType.SINGLE_LINE_TEXT);
-     *     }
-     * }
-     *
-     * async function createNewCheckboxField(table, name) {
-     *     const options = {
-     *         icon: 'check',
-     *         color: 'greenBright',
-     *     };
-     *     if (table.hasPermissionToCreateField(name, FieldType.CHECKBOX, options)) {
-     *         await table.createFieldAsync(name, FieldType.CHECKBOX, options);
-     *     }
-     * }
-     *
-     * async function createNewDateField(table, name) {
-     *     const options = {
-     *         dateFormat: {
-     *             name: 'iso',
-     *         },
-     *     };
-     *     if (table.hasPermissionToCreateField(name, FieldType.DATE, options)) {
-     *         await table.createFieldAsync(name, FieldType.DATE, options);
-     *     }
-     * }
-     * ```
-     */
-  }, {
-    key: "createFieldAsync",
-    value: (function () {
-      var _createFieldAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(name, type, options, description) {
-        var fieldId;
-        return _regenerator.default.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              fieldId = this._sdk.__airtableInterface.idGenerator.generateFieldId();
-              _context3.next = 3;
-              return this._sdk.__mutations.applyMutationAsync({
-                type: _mutations.MutationTypes.CREATE_SINGLE_FIELD,
-                tableId: this.id,
-                id: fieldId,
-                name,
-                config: _objectSpread({
-                  type: type
-                }, options ? {
-                  options
-                } : null),
-                // Coerce undefined to null so that only old SDKs pass "undefined" for description
-                // '' is permitted, as we already set empty descriptions to '' when editing descriptions
-                // from the UI
-                description: description !== null && description !== void 0 ? description : null
-              });
-            case 3:
-              return _context3.abrupt("return", this.getFieldById(fieldId));
-            case 4:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function createFieldAsync(_x3, _x4, _x5, _x6) {
-        return _createFieldAsync.apply(this, arguments);
-      }
-      return createFieldAsync;
-    }() /** @internal */)
-  }, {
-    key: "__triggerOnChangeForDirtyPaths",
-    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
-      var didTableSchemaChange = false;
-      if ((0, _get2.default)((0, _getPrototypeOf2.default)(Table.prototype), "__triggerOnChangeForDirtyPaths", this).call(this, dirtyPaths)) {
-        didTableSchemaChange = true;
-      }
-      if (dirtyPaths.viewOrder) {
-        this._onChange(WatchableTableKeys.views);
-        didTableSchemaChange = true;
+  /**
+   * Creates a new field.
+   *
+   * Similar to creating a field from the Airtable UI, the new field will not be visible
+   * in views that have other hidden fields and views that are publicly shared.
+   *
+   * Throws an error if the user does not have permission to create a field, if invalid
+   * name, type or options are provided, or if creating fields of this type is not supported.
+   *
+   * Refer to {@link FieldType} for supported field types, the write format for options, and
+   * other specifics for certain field types.
+   *
+   * This action is asynchronous. Unlike new records, new fields are **not** created
+   * optimistically locally. You must `await` the returned promise before using the new
+   * field in your extension.
+   *
+   * @param name name for the field. must be case-insensitive unique
+   * @param type type for the field
+   * @param options options for the field. omit for fields without writable options
+   * @param description description for the field. is optional and will be `''` if not specified
+   * or if specified as `null`.
+   *
+   * @example
+   * ```js
+   * async function createNewSingleLineTextField(table, name) {
+   *     if (table.hasPermissionToCreateField(name, FieldType.SINGLE_LINE_TEXT)) {
+   *         await table.createFieldAsync(name, FieldType.SINGLE_LINE_TEXT);
+   *     }
+   * }
+   *
+   * async function createNewCheckboxField(table, name) {
+   *     const options = {
+   *         icon: 'check',
+   *         color: 'greenBright',
+   *     };
+   *     if (table.hasPermissionToCreateField(name, FieldType.CHECKBOX, options)) {
+   *         await table.createFieldAsync(name, FieldType.CHECKBOX, options);
+   *     }
+   * }
+   *
+   * async function createNewDateField(table, name) {
+   *     const options = {
+   *         dateFormat: {
+   *             name: 'iso',
+   *         },
+   *     };
+   *     if (table.hasPermissionToCreateField(name, FieldType.DATE, options)) {
+   *         await table.createFieldAsync(name, FieldType.DATE, options);
+   *     }
+   * }
+   * ```
+   */
+  async createFieldAsync(name, type, options, description) {
+    const fieldId = this._sdk.__airtableInterface.idGenerator.generateFieldId();
+    await this._sdk.__mutations.applyMutationAsync({
+      type: _mutations.MutationTypes.CREATE_SINGLE_FIELD,
+      tableId: this.id,
+      id: fieldId,
+      name,
+      config: {
+        type: type,
+        // In field.options we translate options to null when it's undefined (no options),
+        // but the mutation expects config to match the PublicApiConfig, where it's
+        // not present at all (options: undefined will fail validation).
+        ...(options ? {
+          options
+        } : null)
+      },
+      // Coerce undefined to null so that only old SDKs pass "undefined" for description
+      // '' is permitted, as we already set empty descriptions to '' when editing descriptions
+      // from the UI
+      description: description ?? null
+    });
+    return this.getFieldById(fieldId);
+  }
 
-        // Clean up deleted views
-        var _iterator2 = _createForOfIteratorHelper((0, _private_utils.entries)(this._viewModelsById)),
-          _step2;
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
-              viewId = _step2$value[0],
-              viewModel = _step2$value[1];
-            if (viewModel.isDeleted) {
-              delete this._viewModelsById[viewId];
-            }
-          }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
+  /** @internal */
+  __triggerOnChangeForDirtyPaths(dirtyPaths) {
+    let didTableSchemaChange = false;
+    if (super.__triggerOnChangeForDirtyPaths(dirtyPaths)) {
+      didTableSchemaChange = true;
+    }
+    if (dirtyPaths.viewOrder) {
+      this._onChange(WatchableTableKeys.views);
+      didTableSchemaChange = true;
+
+      // Clean up deleted views
+      for (const [viewId, viewModel] of (0, _private_utils.entries)(this._viewModelsById)) {
+        if (viewModel.isDeleted) {
+          delete this._viewModelsById[viewId];
         }
       }
-      if (dirtyPaths.viewsById) {
-        var _iterator3 = _createForOfIteratorHelper((0, _private_utils.entries)(dirtyPaths.viewsById)),
-          _step3;
-        try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
-              _viewId = _step3$value[0],
-              dirtyViewPaths = _step3$value[1];
-            // Directly access from _viewModelsById to avoid creating
-            // a view model if it doesn't already exist. If it doesn't exist,
-            // nothing can be subscribed to any events on it.
-            var view = this._viewModelsById[_viewId];
-            if (view) {
-              var didViewSchemaChange = view.__triggerOnChangeForDirtyPaths(dirtyViewPaths);
-              if (didViewSchemaChange) {
-                didTableSchemaChange = true;
-              }
-            }
+    }
+    if (dirtyPaths.viewsById) {
+      for (const [viewId, dirtyViewPaths] of (0, _private_utils.entries)(dirtyPaths.viewsById)) {
+        // Directly access from _viewModelsById to avoid creating
+        // a view model if it doesn't already exist. If it doesn't exist,
+        // nothing can be subscribed to any events on it.
+        const view = this._viewModelsById[viewId];
+        if (view) {
+          const didViewSchemaChange = view.__triggerOnChangeForDirtyPaths(dirtyViewPaths);
+          if (didViewSchemaChange) {
+            didTableSchemaChange = true;
           }
-        } catch (err) {
-          _iterator3.e(err);
-        } finally {
-          _iterator3.f();
         }
       }
-      return didTableSchemaChange;
-    }
-  }], [{
-    key: "_isWatchableKey",
-    value: /** @internal */
-    function _isWatchableKey(key) {
-      return (0, _private_utils.isEnumValue)(WatchableTableKeys, key);
     }
-  }]);
-}(_table_core.TableCore);
-/** @internal */
-(0, _defineProperty2.default)(Table, "_className", 'Table');
+    return didTableSchemaChange;
+  }
+}
 var _default = exports.default = Table;