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

package/dist/cjs/shared/models/base_core.js

@@ -1,36 +1,13 @@
 "use strict";
 
-require("core-js/modules/es.symbol.js");
-require("core-js/modules/es.symbol.description.js");
-require("core-js/modules/es.array.from.js");
-require("core-js/modules/es.array.slice.js");
-require("core-js/modules/es.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.WatchableBaseKeys = exports.BaseCore = void 0;
-require("core-js/modules/es.array.iterator.js");
-require("core-js/modules/es.array.map.js");
-require("core-js/modules/es.map.js");
-require("core-js/modules/es.object.to-string.js");
-require("core-js/modules/web.dom-collections.iterator.js");
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-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 _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _private_utils = require("../private_utils");
 var _error_utils = require("../error_utils");
 var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-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 _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // How these model classes work:
 //
 // The single instance of the Base class maintains a reference to a plain JS
@@ -45,7 +22,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
 // since the block developer could mutate it and we'll end up out of sync with
 // liveapp.
 
-var WatchableBaseKeys = exports.WatchableBaseKeys = Object.freeze({
+const WatchableBaseKeys = exports.WatchableBaseKeys = Object.freeze({
   name: 'name',
   tables: 'tables',
   collaborators: 'collaborators',
@@ -64,26 +41,30 @@ var WatchableBaseKeys = exports.WatchableBaseKeys = Object.freeze({
 /** @internal */
 
 /** @internal */
+
 /** @hidden */
-var BaseCore = exports.BaseCore = /*#__PURE__*/function (_AbstractModel) {
+class BaseCore extends _abstract_model.default {
+  /** @internal */
+  static _className = 'BaseCore';
+  /** @internal */
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableBaseKeys, key);
+  }
+  /** @internal */
+
+  /** @internal */
+  _tableRecordStoresByTableId = {};
+  /** @internal */
+
+  /** @internal */
+  _collaboratorIdsByNameAndEmail = null;
   /**
    * @internal
    */
-  function BaseCore(sdk) {
-    var _this;
-    (0, _classCallCheck2.default)(this, BaseCore);
-    _this = _callSuper(this, BaseCore, [sdk, sdk.__airtableInterface.sdkInitData.baseData.id]);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "_tableModelsById", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "_tableRecordStoresByTableId", {});
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "__billingPlanGrouping", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "_collaboratorIdsByNameAndEmail", null);
-    _this._tableModelsById = {}; // Table instances are lazily created by getTableById.
-    _this.__billingPlanGrouping = sdk.__airtableInterface.sdkInitData.baseData.billingPlanGrouping;
-    return _this;
+  constructor(sdk) {
+    super(sdk, sdk.__airtableInterface.sdkInitData.baseData.id);
+    this._tableModelsById = {}; // Table instances are lazily created by getTableById.
+    this.__billingPlanGrouping = sdk.__airtableInterface.sdkInitData.baseData.billingPlanGrouping;
   }
 
   /**
@@ -91,512 +72,411 @@ var BaseCore = exports.BaseCore = /*#__PURE__*/function (_AbstractModel) {
    *
    * @internal
    */
-  (0, _inherits2.default)(BaseCore, _AbstractModel);
-  return (0, _createClass2.default)(BaseCore, [{
-    key: "__sdk",
-    get: function get() {
-      return this._sdk;
-    }
+  get __sdk() {
+    return this._sdk;
+  }
 
-    /**
-     * @internal
-     */
-  }, {
-    key: "_dataOrNullIfDeleted",
-    get: function get() {
-      return this._baseData;
-    }
-    /**
-     * The name of the base.
-     *
-     * @example
-     * ```js
-     * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
-     *
-     * function MyApp() {
-     *     const base = useBase();
-     *     console.log('The name of your base is', base.name);
-     * }
-     * ```
-     */
-  }, {
-    key: "name",
-    get: function get() {
-      return this._data.name;
-    }
+  /**
+   * @internal
+   */
+  get _dataOrNullIfDeleted() {
+    return this._baseData;
+  }
+  /**
+   * The name of the base.
+   *
+   * @example
+   * ```js
+   * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
+   *
+   * function MyApp() {
+   *     const base = useBase();
+   *     console.log('The name of your base is', base.name);
+   * }
+   * ```
+   */
+  get name() {
+    return this._data.name;
+  }
 
-    /**
-     * The workspace id of the base.
-     *
-     * @example
-     * ```js
-     * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
-     *
-     * function MyApp() {
-     *     const base = useBase();
-     *     console.log('The workspace id of your base is', base.workspaceId);
-     * }
-     * ```
-     */
-  }, {
-    key: "workspaceId",
-    get: function get() {
-      return this._data.workspaceId;
-    }
+  /**
+   * The workspace id of the base.
+   *
+   * @example
+   * ```js
+   * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
+   *
+   * function MyApp() {
+   *     const base = useBase();
+   *     console.log('The workspace id of your base is', base.workspaceId);
+   * }
+   * ```
+   */
+  get workspaceId() {
+    return this._data.workspaceId;
+  }
 
-    /**
-     * The color of the base.
-     *
-     * @example
-     * ```js
-     * import {colorUtils, useBase} from '@airtable/blocks/[placeholder-path]/ui';
-     *
-     * function MyApp() {
-     *     const base = useBase();
-     *     return (
-     *         <div style={{backgroundColor: colorUtils.getHexForColor(base.color)}}>
-     *             This div's background is the same color as the base background
-     *         </div>
-     *     );
-     * }
-     * ```
-     */
-  }, {
-    key: "color",
-    get: function get() {
-      return this._data.color;
-    }
+  /**
+   * The color of the base.
+   *
+   * @example
+   * ```js
+   * import {colorUtils, useBase} from '@airtable/blocks/[placeholder-path]/ui';
+   *
+   * function MyApp() {
+   *     const base = useBase();
+   *     return (
+   *         <div style={{backgroundColor: colorUtils.getHexForColor(base.color)}}>
+   *             This div's background is the same color as the base background
+   *         </div>
+   *     );
+   * }
+   * ```
+   */
+  get color() {
+    return this._data.color;
+  }
 
-    /**
-     * The tables in this base. Can be watched to know when tables are created, deleted, or reordered in the base.
-     *
-     * @example
-     * ```js
-     * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
-     *
-     * function MyApp() {
-     *     const base = useBase();
-     *     console.log(`You have ${base.tables.length} tables`);
-     * }
-     * ```
-     */
-  }, {
-    key: "tables",
-    get: function get() {
-      // TODO(kasra): cache and freeze this so it isn't O(n)
-      var tables = [];
-      var _iterator = _createForOfIteratorHelper(this._iterateTableIds()),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _tableId = _step.value;
-          var table = this.getTableByIdIfExists(_tableId);
-          // NOTE: A table's ID may be in tableOrder without the table appearing
-          // in tablesById, in which case getTableById will return null. This
-          // happens if table was just created by the user, since we
-          // wait for the push payload to deliver the table schema.
-          if (table) {
-            tables.push(table);
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+  /**
+   * The tables in this base. Can be watched to know when tables are created, deleted, or reordered in the base.
+   *
+   * @example
+   * ```js
+   * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
+   *
+   * function MyApp() {
+   *     const base = useBase();
+   *     console.log(`You have ${base.tables.length} tables`);
+   * }
+   * ```
+   */
+  get tables() {
+    // TODO(kasra): cache and freeze this so it isn't O(n)
+    const tables = [];
+    for (const tableId of this._iterateTableIds()) {
+      const table = this.getTableByIdIfExists(tableId);
+      // NOTE: A table's ID may be in tableOrder without the table appearing
+      // in tablesById, in which case getTableById will return null. This
+      // happens if table was just created by the user, since we
+      // wait for the push payload to deliver the table schema.
+      if (table) {
+        tables.push(table);
       }
-      return tables;
     }
+    return tables;
+  }
 
-    /** @internal */
-  }, {
-    key: "activeCollaborators",
-    get:
-    /**
-     * The users who have access to this base.
-     *
-     * @example
-     * ```js
-     * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
-     *
-     * function MyApp() {
-     *     const base = useBase();
-     *     console.log(base.activeCollaborators[0].email);
-     * }
-     * ```
-     */
-    function get() {
-      return this._data.activeCollaboratorIds.map(collaboratorId => this.getCollaboratorById(collaboratorId));
-    }
-    /**
-     * The user matching the given ID, or `null` if that user does not exist or does not have access
-     * to this base.
-     *
-     * @param collaboratorId The ID of the user.
-     */
-  }, {
-    key: "getCollaboratorByIdIfExists",
-    value: function getCollaboratorByIdIfExists(collaboratorId) {
-      var collaboratorsById = this._data.collaboratorsById;
-      return (0, _private_utils.has)(collaboratorsById, collaboratorId) ? collaboratorsById[collaboratorId] : null;
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * The users who have access to this base.
+   *
+   * @example
+   * ```js
+   * import {useBase} from '@airtable/blocks/[placeholder-path]/ui';
+   *
+   * function MyApp() {
+   *     const base = useBase();
+   *     console.log(base.activeCollaborators[0].email);
+   * }
+   * ```
+   */
+  get activeCollaborators() {
+    return this._data.activeCollaboratorIds.map(collaboratorId => this.getCollaboratorById(collaboratorId));
+  }
+  /**
+   * The user matching the given ID, or `null` if that user does not exist or does not have access
+   * to this base.
+   *
+   * @param collaboratorId The ID of the user.
+   */
+  getCollaboratorByIdIfExists(collaboratorId) {
+    const collaboratorsById = this._data.collaboratorsById;
+    return (0, _private_utils.has)(collaboratorsById, collaboratorId) ? collaboratorsById[collaboratorId] : null;
+  }
+  /**
+   * The user matching the given ID. Throws if that user does not exist
+   * or does not have access to this base. Use {@link getCollaboratorByIdIfExists}
+   * instead if you are unsure whether a collaborator with the given ID exists
+   * and has access to this base.
+   *
+   * @param collaboratorId The ID of the user.
+   */
+  getCollaboratorById(collaboratorId) {
+    const collaborator = this.getCollaboratorByIdIfExists(collaboratorId);
+    if (!collaborator) {
+      throw (0, _error_utils.spawnError)("No collaborator with ID %s has access to base '%s'", collaboratorId, this.name);
     }
-    /**
-     * The user matching the given ID. Throws if that user does not exist
-     * or does not have access to this base. Use {@link getCollaboratorByIdIfExists}
-     * instead if you are unsure whether a collaborator with the given ID exists
-     * and has access to this base.
-     *
-     * @param collaboratorId The ID of the user.
-     */
-  }, {
-    key: "getCollaboratorById",
-    value: function getCollaboratorById(collaboratorId) {
-      var collaborator = this.getCollaboratorByIdIfExists(collaboratorId);
-      if (!collaborator) {
-        throw (0, _error_utils.spawnError)("No collaborator with ID %s has access to base '%s'", collaboratorId, this.name);
-      }
-      return collaborator;
+    return collaborator;
+  }
+  /**
+   * The user matching the given ID, name, or email address. Returns null if that user does not
+   * exist or does not have access to this base.
+   *
+   * 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 getCollaboratorByIdIfExists} method instead.
+   *
+   * @param collaboratorIdOrNameOrEmail The ID of the user.
+   */
+  getCollaboratorIfExists(idOrNameOrEmail) {
+    const collaboratorById = this.getCollaboratorByIdIfExists(idOrNameOrEmail);
+    if (collaboratorById) {
+      return collaboratorById;
     }
-    /**
-     * The user matching the given ID, name, or email address. Returns null if that user does not
-     * exist or does not have access to this base.
-     *
-     * 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 getCollaboratorByIdIfExists} method instead.
-     *
-     * @param collaboratorIdOrNameOrEmail The ID of the user.
-     */
-  }, {
-    key: "getCollaboratorIfExists",
-    value: function getCollaboratorIfExists(idOrNameOrEmail) {
-      var collaboratorById = this.getCollaboratorByIdIfExists(idOrNameOrEmail);
-      if (collaboratorById) {
-        return collaboratorById;
-      }
-      if (!this._collaboratorIdsByNameAndEmail) {
-        this._collaboratorIdsByNameAndEmail = new Map();
-        var _iterator2 = _createForOfIteratorHelper((0, _private_utils.entries)(this._data.collaboratorsById)),
-          _step2;
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
-              id = _step2$value[0],
-              _step2$value$ = _step2$value[1],
-              email = _step2$value$.email,
-              name = _step2$value$.name;
-            this._collaboratorIdsByNameAndEmail.set(email, id);
-            // we prevent `@` in names so theoretically we shouldn't encounter any collisions
-            // between names and emails, but names themselves may not be unique. as we build the
-            // name hash, we only add new values rather than overwrite existing ones. this means
-            // that we'll prefer emails to names in the event of a collision.
-            if (name && !this._collaboratorIdsByNameAndEmail.has(name)) {
-              this._collaboratorIdsByNameAndEmail.set(name, id);
-            }
-          }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
+    if (!this._collaboratorIdsByNameAndEmail) {
+      this._collaboratorIdsByNameAndEmail = new Map();
+      for (const [id, {
+        email,
+        name
+      }] of (0, _private_utils.entries)(this._data.collaboratorsById)) {
+        this._collaboratorIdsByNameAndEmail.set(email, id);
+        // we prevent `@` in names so theoretically we shouldn't encounter any collisions
+        // between names and emails, but names themselves may not be unique. as we build the
+        // name hash, we only add new values rather than overwrite existing ones. this means
+        // that we'll prefer emails to names in the event of a collision.
+        if (name && !this._collaboratorIdsByNameAndEmail.has(name)) {
+          this._collaboratorIdsByNameAndEmail.set(name, id);
         }
       }
-      var idForNameOrEmail = this._collaboratorIdsByNameAndEmail.get(idOrNameOrEmail);
-      if (idForNameOrEmail !== undefined) {
-        return this.getCollaboratorById(idForNameOrEmail);
-      }
-      return null;
-    }
-    /**
-     * The user matching the given ID, name, or email address. Throws if that user does not exist
-     * or does not have access to this base. Use {@link getCollaboratorIfExists} instead if you are
-     * unsure whether a collaborator with the given ID exists and has access to this base.
-     *
-     * 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 getCollaboratorById} method instead.
-     *
-     * @param collaboratorIdOrNameOrEmail The ID of the user.
-     */
-  }, {
-    key: "getCollaborator",
-    value: function getCollaborator(idOrNameOrEmail) {
-      var collaborator = this.getCollaboratorIfExists(idOrNameOrEmail);
-      if (!collaborator) {
-        throw (0, _error_utils.spawnError)("No collaborator with ID, name, or email of '%s' is in base '%s'", idOrNameOrEmail, this.name);
-      }
-      return collaborator;
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "__getBaseData",
-    value: function __getBaseData() {
-      return this._data;
+    const idForNameOrEmail = this._collaboratorIdsByNameAndEmail.get(idOrNameOrEmail);
+    if (idForNameOrEmail !== undefined) {
+      return this.getCollaboratorById(idForNameOrEmail);
     }
-    /**
-     * The table matching the given ID, or `null` if that table does not exist in this base.
-     *
-     * @param tableId The ID of the table.
-     */
-  }, {
-    key: "getTableByIdIfExists",
-    value: function getTableByIdIfExists(tableId) {
-      if (!this._data.tablesById[tableId]) {
-        return null;
-      } else {
-        if (!this._tableModelsById[tableId]) {
-          this._tableModelsById[tableId] = this._constructTable(tableId);
-        }
-        return this._tableModelsById[tableId];
-      }
+    return null;
+  }
+  /**
+   * The user matching the given ID, name, or email address. Throws if that user does not exist
+   * or does not have access to this base. Use {@link getCollaboratorIfExists} instead if you are
+   * unsure whether a collaborator with the given ID exists and has access to this base.
+   *
+   * 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 getCollaboratorById} method instead.
+   *
+   * @param collaboratorIdOrNameOrEmail The ID of the user.
+   */
+  getCollaborator(idOrNameOrEmail) {
+    const collaborator = this.getCollaboratorIfExists(idOrNameOrEmail);
+    if (!collaborator) {
+      throw (0, _error_utils.spawnError)("No collaborator with ID, name, or email of '%s' is in base '%s'", idOrNameOrEmail, this.name);
     }
-    /**
-     * The table matching the given ID. Throws if that table does not exist in this base. Use
-     * {@link getTableByIdIfExists} instead if you are unsure whether a table exists with the given
-     * ID.
-     *
-     * @param tableId The ID of the table.
-     */
-  }, {
-    key: "getTableById",
-    value: function getTableById(tableId) {
-      var table = this.getTableByIdIfExists(tableId);
-      if (!table) {
-        throw (0, _error_utils.spawnError)("No table with ID %s in base '%s'", tableId, this.name);
+    return collaborator;
+  }
+  /**
+   * @internal
+   */
+  __getBaseData() {
+    return this._data;
+  }
+  /**
+   * The table matching the given ID, or `null` if that table does not exist in this base.
+   *
+   * @param tableId The ID of the table.
+   */
+  getTableByIdIfExists(tableId) {
+    if (!this._data.tablesById[tableId]) {
+      return null;
+    } else {
+      if (!this._tableModelsById[tableId]) {
+        this._tableModelsById[tableId] = this._constructTable(tableId);
       }
-      return table;
+      return this._tableModelsById[tableId];
     }
-    /**
-     * The table matching the given name, or `null` if no table exists with that name in this base.
-     *
-     * @param tableName The name of the table you're looking for.
-     */
-  }, {
-    key: "getTableByNameIfExists",
-    value: function getTableByNameIfExists(tableName) {
-      var _iterator3 = _createForOfIteratorHelper((0, _private_utils.entries)(this._data.tablesById)),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
-            _tableId2 = _step3$value[0],
-            tableData = _step3$value[1];
-          if (tableData.name === tableName) {
-            return this.getTableByIdIfExists(_tableId2);
-          }
-        }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
-      return null;
+  }
+  /**
+   * The table matching the given ID. Throws if that table does not exist in this base. Use
+   * {@link getTableByIdIfExists} instead if you are unsure whether a table exists with the given
+   * ID.
+   *
+   * @param tableId The ID of the table.
+   */
+  getTableById(tableId) {
+    const table = this.getTableByIdIfExists(tableId);
+    if (!table) {
+      throw (0, _error_utils.spawnError)("No table with ID %s in base '%s'", tableId, this.name);
     }
-    /**
-     * The table matching the given name. Throws if no table exists with that name in this base. Use
-     * {@link getTableByNameIfExists} instead if you are unsure whether a table exists with the
-     * given name.
-     *
-     * @param tableName The name of the table you're looking for.
-     */
-  }, {
-    key: "getTableByName",
-    value: function getTableByName(tableName) {
-      var table = this.getTableByNameIfExists(tableName);
-      if (!table) {
-        throw (0, _error_utils.spawnError)("No table named '%s' in base '%s'", tableName, this.name);
+    return table;
+  }
+  /**
+   * The table matching the given name, or `null` if no table exists with that name in this base.
+   *
+   * @param tableName The name of the table you're looking for.
+   */
+  getTableByNameIfExists(tableName) {
+    for (const [tableId, tableData] of (0, _private_utils.entries)(this._data.tablesById)) {
+      if (tableData.name === tableName) {
+        return this.getTableByIdIfExists(tableId);
       }
-      return table;
     }
-    /**
-     * The table matching the given ID or name. Returns `null` if no matching table exists within
-     * this base.
-     *
-     * 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 getTableByIdIfExists} or
-     * {@link getTableByNameIfExists} methods instead.
-     *
-     * @param tableIdOrName The ID or name of the table you're looking for.
-     */
-  }, {
-    key: "getTableIfExists",
-    value: function getTableIfExists(tableIdOrName) {
-      var _this$getTableByIdIfE;
-      return (_this$getTableByIdIfE = this.getTableByIdIfExists(tableIdOrName)) !== null && _this$getTableByIdIfE !== void 0 ? _this$getTableByIdIfE : this.getTableByNameIfExists(tableIdOrName);
+    return null;
+  }
+  /**
+   * The table matching the given name. Throws if no table exists with that name in this base. Use
+   * {@link getTableByNameIfExists} instead if you are unsure whether a table exists with the
+   * given name.
+   *
+   * @param tableName The name of the table you're looking for.
+   */
+  getTableByName(tableName) {
+    const table = this.getTableByNameIfExists(tableName);
+    if (!table) {
+      throw (0, _error_utils.spawnError)("No table named '%s' in base '%s'", tableName, this.name);
     }
-    /**
-     * The table matching the given ID or name. Throws if no matching table exists within this base.
-     * Use {@link getTableIfExists} instead if you are unsure whether a table 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 getTableById} or {@link getTableByName} methods
-     * instead.
-     *
-     * @param tableIdOrName The ID or name of the table you're looking for.
-     */
-  }, {
-    key: "getTable",
-    value: function getTable(tableIdOrName) {
-      var table = this.getTableIfExists(tableIdOrName);
-      if (!table) {
-        throw (0, _error_utils.spawnError)("No table with ID or name '%s' in base '%s'", tableIdOrName, this.name);
-      }
-      return table;
+    return table;
+  }
+  /**
+   * The table matching the given ID or name. Returns `null` if no matching table exists within
+   * this base.
+   *
+   * 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 getTableByIdIfExists} or
+   * {@link getTableByNameIfExists} methods instead.
+   *
+   * @param tableIdOrName The ID or name of the table you're looking for.
+   */
+  getTableIfExists(tableIdOrName) {
+    return this.getTableByIdIfExists(tableIdOrName) ?? this.getTableByNameIfExists(tableIdOrName);
+  }
+  /**
+   * The table matching the given ID or name. Throws if no matching table exists within this base.
+   * Use {@link getTableIfExists} instead if you are unsure whether a table 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 getTableById} or {@link getTableByName} methods
+   * instead.
+   *
+   * @param tableIdOrName The ID or name of the table you're looking for.
+   */
+  getTable(tableIdOrName) {
+    const table = this.getTableIfExists(tableIdOrName);
+    if (!table) {
+      throw (0, _error_utils.spawnError)("No table with ID or name '%s' in base '%s'", tableIdOrName, this.name);
     }
+    return table;
+  }
 
-    /**
-     * Returns the maximum number of records allowed in each table of this base.
-     */
-  }, {
-    key: "getMaxRecordsPerTable",
-    value: function getMaxRecordsPerTable() {
-      var _this$_data$maxRowsPe;
-      return (_this$_data$maxRowsPe = this._data.maxRowsPerTable) !== null && _this$_data$maxRowsPe !== void 0 ? _this$_data$maxRowsPe : 100000;
-    }
+  /**
+   * Returns the maximum number of records allowed in each table of this base.
+   */
+  getMaxRecordsPerTable() {
+    return this._data.maxRowsPerTable ?? 100000;
+  }
 
-    /**
-     * @internal
-     */
-  }, {
-    key: "__getRecordStore",
-    value: function __getRecordStore(tableId) {
-      if ((0, _private_utils.has)(this._tableRecordStoresByTableId, tableId)) {
-        return this._tableRecordStoresByTableId[tableId];
-      }
-      (0, _error_utils.invariant)(this._data.tablesById[tableId], 'table must exist');
-      var newRecordStore = this._constructRecordStore(this._sdk, tableId);
-      this._tableRecordStoresByTableId[tableId] = newRecordStore;
-      return newRecordStore;
+  /**
+   * @internal
+   */
+  __getRecordStore(tableId) {
+    if ((0, _private_utils.has)(this._tableRecordStoresByTableId, tableId)) {
+      return this._tableRecordStoresByTableId[tableId];
     }
+    (0, _error_utils.invariant)(this._data.tablesById[tableId], 'table must exist');
+    const newRecordStore = this._constructRecordStore(this._sdk, tableId);
+    this._tableRecordStoresByTableId[tableId] = newRecordStore;
+    return newRecordStore;
+  }
 
-    /**
-     * @internal
-     */
-  }, {
-    key: "__triggerOnChangeForChangedPaths",
-    value: function __triggerOnChangeForChangedPaths(changedPaths) {
-      var didSchemaChange = false;
-      if (changedPaths.name) {
-        this._onChange(WatchableBaseKeys.name);
-        didSchemaChange = true;
-      }
-      if (changedPaths.color) {
-        this._onChange(WatchableBaseKeys.color);
+  /**
+   * @internal
+   */
+  __triggerOnChangeForChangedPaths(changedPaths) {
+    let didSchemaChange = false;
+    if (changedPaths.name) {
+      this._onChange(WatchableBaseKeys.name);
+      didSchemaChange = true;
+    }
+    if (changedPaths.color) {
+      this._onChange(WatchableBaseKeys.color);
+      didSchemaChange = true;
+    }
+    const {
+      tablesById
+    } = changedPaths;
+    if (tablesById) {
+      if ((0, _private_utils.isDeepEqual)(tablesById, {
+        _isDirty: true
+      })) {
+        // If the changedPath is that tablesById is dirty in general, we need to
+        // trigger a schema change event. This happens in interface blocks
+        // when we reinitialize the tablesById as a whole due to the QueryModels
+        // changing. See https://github.com/Hyperbase/hyperbase/blob/b50a8992d333bcef3c906d61886fc69727a8e94b/client/components/blocks/block_frame.tsx#L645
         didSchemaChange = true;
-      }
-      var tablesById = changedPaths.tablesById;
-      if (tablesById) {
-        if ((0, _private_utils.isDeepEqual)(tablesById, {
-          _isDirty: true
-        })) {
-          // If the changedPath is that tablesById is dirty in general, we need to
-          // trigger a schema change event. This happens in interface blocks
-          // when we reinitialize the tablesById as a whole due to the QueryModels
-          // changing. See https://github.com/Hyperbase/hyperbase/blob/b50a8992d333bcef3c906d61886fc69727a8e94b/client/components/blocks/block_frame.tsx#L645
-          didSchemaChange = true;
-        } else {
-          var _iterator4 = _createForOfIteratorHelper((0, _private_utils.entries)(tablesById)),
-            _step4;
-          try {
-            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
-                _tableId3 = _step4$value[0],
-                dirtyTablePaths = _step4$value[1];
-              var table = this.getTableByIdIfExists(_tableId3);
-              if (table && dirtyTablePaths) {
-                var didTableSchemaChange = table.__triggerOnChangeForDirtyPaths(dirtyTablePaths);
-                if (didTableSchemaChange) {
-                  didSchemaChange = true;
-                }
-              }
+      } else {
+        for (const [tableId, dirtyTablePaths] of (0, _private_utils.entries)(tablesById)) {
+          const table = this.getTableByIdIfExists(tableId);
+          if (table && dirtyTablePaths) {
+            const didTableSchemaChange = table.__triggerOnChangeForDirtyPaths(dirtyTablePaths);
+            if (didTableSchemaChange) {
+              didSchemaChange = true;
             }
-          } catch (err) {
-            _iterator4.e(err);
-          } finally {
-            _iterator4.f();
           }
         }
       }
-      if (changedPaths.collaboratorsById || changedPaths.activeCollaboratorIds) {
-        this._onChange(WatchableBaseKeys.collaborators);
-      }
-      if (changedPaths.appInterface) {
-        didSchemaChange = true;
-      }
-      if (didSchemaChange) {
-        this._onChange(WatchableBaseKeys.schema);
-      }
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "__applyChangesWithoutTriggeringEvents",
-    value: function __applyChangesWithoutTriggeringEvents(changes) {
-      // Internal method.
-      // After applying all changes, changedPaths will have the same shape as
-      // the subset of this._data that changed. For example, if some table's
-      // name changes, changedPaths will be {tablesById: {tbl123: name: {_isDirty: true}}}.
-      // Use it to call __triggerOnChangeForChangedPaths to trigger change events for
-      // effected models
-      var changedPaths = {};
-      var _iterator5 = _createForOfIteratorHelper(changes),
-        _step5;
-      try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var change = _step5.value;
-          this._applyChange(change.path, change.value, changedPaths);
-        }
-      } catch (err) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
-      }
-      return changedPaths;
+    if (changedPaths.collaboratorsById || changedPaths.activeCollaboratorIds) {
+      this._onChange(WatchableBaseKeys.collaborators);
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "_applyChange",
-    value: function _applyChange(path, value, changedPathsByRef) {
-      var dataSubtree = this._data;
-      var dirtySubtree = changedPathsByRef;
-      for (var i = 0; i < path.length - 1; i++) {
-        var part = path[i];
-        if (!dataSubtree[part]) {
-          // Certain fields are stored sparsely (e.g. cellValuesByFieldId),
-          // so create an object on demand if needed.
-          dataSubtree[part] = {};
-        }
-        dataSubtree = dataSubtree[part];
-        if (!dirtySubtree[part]) {
-          dirtySubtree[part] = {};
-        }
-        (0, _error_utils.invariant)(dirtySubtree[part], 'dirtySubtree');
-        dirtySubtree = dirtySubtree[part];
-      }
-      var lastPathPart = path[path.length - 1];
-      var didChange = !(0, _private_utils.isDeepEqual)(dataSubtree[lastPathPart], value);
-      if (value === undefined) {
-        delete dataSubtree[lastPathPart];
-      } else {
-        dataSubtree[lastPathPart] = value;
+    if (changedPaths.appInterface) {
+      didSchemaChange = true;
+    }
+    if (didSchemaChange) {
+      this._onChange(WatchableBaseKeys.schema);
+    }
+  }
+  /**
+   * @internal
+   */
+  __applyChangesWithoutTriggeringEvents(changes) {
+    // Internal method.
+    // After applying all changes, changedPaths will have the same shape as
+    // the subset of this._data that changed. For example, if some table's
+    // name changes, changedPaths will be {tablesById: {tbl123: name: {_isDirty: true}}}.
+    // Use it to call __triggerOnChangeForChangedPaths to trigger change events for
+    // effected models
+    const changedPaths = {};
+    for (const change of changes) {
+      this._applyChange(change.path, change.value, changedPaths);
+    }
+    return changedPaths;
+  }
+  /**
+   * @internal
+   */
+  _applyChange(path, value, changedPathsByRef) {
+    let dataSubtree = this._data;
+    let dirtySubtree = changedPathsByRef;
+    for (let i = 0; i < path.length - 1; i++) {
+      const part = path[i];
+      if (!dataSubtree[part]) {
+        // Certain fields are stored sparsely (e.g. cellValuesByFieldId),
+        // so create an object on demand if needed.
+        dataSubtree[part] = {};
       }
-      if (didChange) {
-        if (!dirtySubtree[lastPathPart]) {
-          dirtySubtree[lastPathPart] = {};
-        }
-        (0, _error_utils.invariant)(dirtySubtree[lastPathPart], 'dirtySubtree');
-        dirtySubtree[lastPathPart]._isDirty = true;
+      dataSubtree = dataSubtree[part];
+      if (!dirtySubtree[part]) {
+        dirtySubtree[part] = {};
       }
+      (0, _error_utils.invariant)(dirtySubtree[part], 'dirtySubtree');
+      dirtySubtree = dirtySubtree[part];
     }
-  }], [{
-    key: "_isWatchableKey",
-    value: /** @internal */
-    function _isWatchableKey(key) {
-      return (0, _private_utils.isEnumValue)(WatchableBaseKeys, key);
+    const lastPathPart = path[path.length - 1];
+    const didChange = !(0, _private_utils.isDeepEqual)(dataSubtree[lastPathPart], value);
+    if (value === undefined) {
+      delete dataSubtree[lastPathPart];
+    } else {
+      dataSubtree[lastPathPart] = value;
     }
-  }]);
-}(_abstract_model.default);
-/** @internal */
-(0, _defineProperty2.default)(BaseCore, "_className", 'BaseCore');
+    if (didChange) {
+      if (!dirtySubtree[lastPathPart]) {
+        dirtySubtree[lastPathPart] = {};
+      }
+      (0, _error_utils.invariant)(dirtySubtree[lastPathPart], 'dirtySubtree');
+      dirtySubtree[lastPathPart]._isDirty = true;
+    }
+  }
+}
+exports.BaseCore = BaseCore;