@airtable/blocks 0.0.0-experimental-20e3506bd-20250428

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

@@ -0,0 +1,214 @@
+"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.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.to-string.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.SessionCore = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.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 _error_utils = require("../error_utils");
+var _private_utils = require("../private_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; })(); } /** @module @airtable/blocks/models: Session */ /** */
+/** @hidden */
+
+var WatchableSessionKeys = Object.freeze({
+  permissionLevel: 'permissionLevel',
+  // NOTE: the current user's identity will never change, but their name/email/profile pic/etc. can.
+  currentUser: 'currentUser'
+});
+
+/**
+ * Watchable keys in {@link Session}.
+ * - `currentUser`
+ * - `permissionLevel`
+ */
+/** @hidden */
+var SessionCore = exports.SessionCore = /*#__PURE__*/function (_AbstractModel) {
+  /**
+   * @internal
+   */
+  function SessionCore(sdk) {
+    var _this;
+    (0, _classCallCheck2.default)(this, SessionCore);
+    _this = _callSuper(this, SessionCore, [sdk, 'session']);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_airtableInterface", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_sessionData", void 0);
+    _this._airtableInterface = sdk.__airtableInterface;
+    var _this$_airtableInterf = _this._airtableInterface.sdkInitData.baseData,
+      permissionLevel = _this$_airtableInterf.permissionLevel,
+      currentUserId = _this$_airtableInterf.currentUserId,
+      enabledFeatureNames = _this$_airtableInterf.enabledFeatureNames;
+    _this._sessionData = {
+      permissionLevel,
+      currentUserId,
+      enabledFeatureNames
+    };
+    Object.seal(_this);
+    return _this;
+  }
+
+  /**
+   * @internal
+   */
+  (0, _inherits2.default)(SessionCore, _AbstractModel);
+  return (0, _createClass2.default)(SessionCore, [{
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      return this._sessionData;
+    }
+
+    /**
+     * The current user, or `null` if the extension is running in a publicly shared base.
+     *
+     * @example
+     * ```js
+     * import {useSession} from '@airtable/blocks/ui';
+     *
+     * function CurrentUser() {
+     *     const session = useSession();
+     *
+     *     if (!session.currentUser) {
+     *         return <div>This extension is being used in a public share.</div>;
+     *     }
+     *
+     *     return <ul>
+     *         <li>ID: {session.currentUser.id}</li>
+     *         <li>E-mail: {session.currentUser.email}</li>
+     *         <li>Name: {session.currentUser.name}</li>
+     *     </ul>;
+     * }
+     * ```
+     */
+  }, {
+    key: "currentUser",
+    get: function get() {
+      var userId = this._sessionData.currentUserId;
+      if (!userId) {
+        return null;
+      } else {
+        var base = this._sdk.base;
+        return base.getCollaboratorByIdIfExists(userId);
+      }
+    }
+    /**
+     * Returns true if `featureName` is enabled and automatically tracks an exposure.
+     *
+     * @internal
+     */
+  }, {
+    key: "__isFeatureEnabled",
+    value: function __isFeatureEnabled(featureName) {
+      this._airtableInterface.trackExposure(featureName);
+      return this.__peekIfFeatureIsEnabled(featureName);
+    }
+
+    /**
+     * Returns true if `featureName` is enabled; does not track an exposure.
+     *
+     * @internal
+     */
+  }, {
+    key: "__peekIfFeatureIsEnabled",
+    value: function __peekIfFeatureIsEnabled(featureName) {
+      return this._sessionData.enabledFeatureNames.includes(featureName);
+    }
+
+    /**
+     * @internal
+     */
+  }, {
+    key: "__applyChangesWithoutTriggeringEvents",
+    value: function __applyChangesWithoutTriggeringEvents(changes) {
+      var changedKeys = {
+        [WatchableSessionKeys.permissionLevel]: false,
+        [WatchableSessionKeys.currentUser]: false
+      };
+      var _iterator = _createForOfIteratorHelper(changes),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _step.value,
+            path = _step$value.path,
+            value = _step$value.value;
+          if (path[0] === 'permissionLevel') {
+            (0, _error_utils.invariant)(path.length === 1, 'cannot set within permissionLevel');
+
+            // NOTE: just verify that the permission level is a string (rather than
+            // checking isEnumValue against PermissionLevels) in case new permission
+            // levels are added on the liveapp side. Permissions behavior gets routed
+            // through the checkPermissionsForMutation AirtableInterface helper, so we
+            // should still be able to handle unknown permission levels.
+            (0, _error_utils.invariant)(typeof value === 'string', 'permissionLevel must be a string');
+            this._sessionData.permissionLevel = value;
+            changedKeys[WatchableSessionKeys.permissionLevel] = true;
+          }
+
+          // TODO(emma): fire change only when the current user's info changes
+          if (path[0] === 'collaboratorsById') {
+            changedKeys[WatchableSessionKeys.currentUser] = true;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return changedKeys;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__triggerOnChangeForChangedKeys",
+    value: function __triggerOnChangeForChangedKeys(changedKeys) {
+      var _iterator2 = _createForOfIteratorHelper((0, _private_utils.entries)(changedKeys)),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
+            key = _step2$value[0],
+            didChange = _step2$value[1];
+          if (didChange) {
+            this._onChange(key);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableSessionKeys, key);
+    }
+  }]);
+}(_abstract_model.default);
+/** @internal */
+(0, _defineProperty2.default)(SessionCore, "_className", 'SessionCore');

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

@@ -0,0 +1,460 @@
+"use strict";
+
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.to-string.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.WatchableTableKeysCore = exports.TableCore = void 0;
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.object.from-entries.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"));
+var _field_core = require("./field_core");
+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; })(); }
+// This doesn't follow our enum naming conventions because we want the keys
+// to mirror the method/getter names on the model class.
+var WatchableTableKeysCore = exports.WatchableTableKeysCore = Object.freeze({
+  name: 'name',
+  description: 'description',
+  fields: 'fields'
+});
+
+/** @hidden */
+/** @hidden */
+var TableCore = exports.TableCore = /*#__PURE__*/function (_AbstractModel) {
+  /**
+   * @internal
+   */
+  function TableCore(parentBase, recordStore, tableId, sdk) {
+    var _this;
+    (0, _classCallCheck2.default)(this, TableCore);
+    _this = _callSuper(this, TableCore, [sdk, tableId]);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_parentBase", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_recordStore", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_fieldModelsById", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_cachedFieldNamesById", void 0);
+    _this._parentBase = parentBase;
+    _this._recordStore = recordStore;
+    _this._fieldModelsById = {}; // Field instances are lazily created by getFieldById.
+    _this._cachedFieldNamesById = null;
+    return _this;
+  }
+
+  /**
+   * @internal
+   */
+  (0, _inherits2.default)(TableCore, _AbstractModel);
+  return (0, _createClass2.default)(TableCore, [{
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      var _this$_baseData$table;
+      return (_this$_baseData$table = this._baseData.tablesById[this._id]) !== null && _this$_baseData$table !== void 0 ? _this$_baseData$table : null;
+    }
+    /**
+     * The base that this table belongs to.
+     *
+     * @internal (since we may not be able to return parent model instances in the immutable models world)
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * const table = base.getTableByName('Table 1');
+     * console.log(table.parentBase.id === base.id);
+     * // => true
+     * ```
+     */
+  }, {
+    key: "parentBase",
+    get: function get() {
+      return this._parentBase;
+    }
+    /**
+     * The name of the table. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myTable.name);
+     * // => 'Table 1'
+     * ```
+     */
+  }, {
+    key: "name",
+    get: function get() {
+      return this._data.name;
+    }
+    /**
+     * The description of the table, if it has one. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myTable.description);
+     * // => 'This is my table'
+     * ```
+     */
+  }, {
+    key: "description",
+    get: function get() {
+      return this._data.description;
+    }
+    /**
+     * The table's primary field. Every table has exactly one primary
+     * field. The primary field of a table will not change.
+     *
+     * @example
+     * ```js
+     * console.log(myTable.primaryField.name);
+     * // => 'Name'
+     * ```
+     */
+  }, {
+    key: "primaryField",
+    get: function get() {
+      var primaryField = this.getFieldById(this._data.primaryFieldId);
+      return primaryField;
+    }
+    /**
+     * The fields in this table. The order is arbitrary, since fields are
+     * only ordered in the context of a specific view.
+     *
+     * Can be watched to know when fields are created or deleted.
+     *
+     * @example
+     * ```js
+     * console.log(`This table has ${myTable.fields.length} fields`);
+     * ```
+     */
+  }, {
+    key: "fields",
+    get: function get() {
+      // TODO(kasra): is it confusing that this returns an array, since the order
+      // is arbitrary?
+      // TODO(kasra): cache and freeze this so it isn't O(n)
+      var fields = [];
+      for (var _i = 0, _Object$keys = Object.keys(this._data.fieldsById); _i < _Object$keys.length; _i++) {
+        var _fieldId = _Object$keys[_i];
+        var field = this.getFieldById(_fieldId);
+        fields.push(field);
+      }
+      return fields;
+    }
+    /**
+     * Gets the field matching the given ID, or `null` if that field does not exist in this table.
+      * @param fieldId The ID of the field.
+     * @example
+     * ```js
+     * const fieldId = 'fldxxxxxxxxxxxxxx';
+     * const field = myTable.getFieldByIdIfExists(fieldId);
+     * if (field !== null) {
+     *     console.log(field.name);
+     * } else {
+     *     console.log('No field exists with that ID');
+     * }
+     * ```
+     */
+  }, {
+    key: "getFieldByIdIfExists",
+    value: function getFieldByIdIfExists(fieldId) {
+      if (!this._data.fieldsById[fieldId]) {
+        return null;
+      } else {
+        if (!this._fieldModelsById[fieldId]) {
+          this._fieldModelsById[fieldId] = this._constructField(fieldId);
+        }
+        return this._fieldModelsById[fieldId];
+      }
+    }
+    /** @internal */
+  }, {
+    key: "getFieldById",
+    value:
+    /**
+     * Gets the field matching the given ID. Throws if that field does not exist in this table. Use
+     * {@link getFieldByIdIfExists} instead if you are unsure whether a field exists with the given
+     * ID.
+     *
+     * @param fieldId The ID of the field.
+     * @example
+     * ```js
+     * const fieldId = 'fldxxxxxxxxxxxxxx';
+     * const field = myTable.getFieldById(fieldId);
+     * console.log(field.name);
+     * // => 'Name'
+     * ```
+     */
+    function getFieldById(fieldId) {
+      var field = this.getFieldByIdIfExists(fieldId);
+      if (!field) {
+        throw (0, _error_utils.spawnError)("No field with ID %s in table '%s'", fieldId, this.name);
+      }
+      return field;
+    }
+    /**
+     * Gets the field matching the given name, or `null` if no field exists with that name in this
+     * table.
+     *
+     * @param fieldName The name of the field you're looking for.
+     * @example
+     * ```js
+     * const field = myTable.getFieldByNameIfExists('Name');
+     * if (field !== null) {
+     *     console.log(field.id);
+     * } else {
+     *     console.log('No field exists with that name');
+     * }
+     * ```
+     */
+  }, {
+    key: "getFieldByNameIfExists",
+    value: function getFieldByNameIfExists(fieldName) {
+      var _iterator = _createForOfIteratorHelper((0, _private_utils.entries)(this._data.fieldsById)),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+            _fieldId2 = _step$value[0],
+            fieldData = _step$value[1];
+          if (fieldData.name === fieldName) {
+            return this.getFieldByIdIfExists(_fieldId2);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return null;
+    }
+    /**
+     * Gets the field matching the given name. Throws if no field exists with that name in this
+     * table. Use {@link getFieldByNameIfExists} instead if you are unsure whether a field exists
+     * with the given name.
+     *
+     * @param fieldName The name of the field you're looking for.
+     * @example
+     * ```js
+     * const field = myTable.getFieldByName('Name');
+     * console.log(field.id);
+     * // => 'fldxxxxxxxxxxxxxx'
+     * ```
+     */
+  }, {
+    key: "getFieldByName",
+    value: function getFieldByName(fieldName) {
+      var field = this.getFieldByNameIfExists(fieldName);
+      if (!field) {
+        throw (0, _error_utils.spawnError)("No field named '%s' in table '%s'", fieldName, this.name);
+      }
+      return field;
+    }
+    /**
+     * The field matching the given ID or name. Returns `null` if no matching field 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 getFieldByIdIfExists} or
+     * {@link getFieldByNameIfExists} methods instead.
+     *
+     * @param fieldIdOrName The ID or name of the field you're looking for.
+     */
+  }, {
+    key: "getFieldIfExists",
+    value: function getFieldIfExists(fieldIdOrName) {
+      var _this$getFieldByIdIfE;
+      return (_this$getFieldByIdIfE = this.getFieldByIdIfExists(fieldIdOrName)) !== null && _this$getFieldByIdIfE !== void 0 ? _this$getFieldByIdIfE : this.getFieldByNameIfExists(fieldIdOrName);
+    }
+    /**
+     * The field matching the given ID or name. Throws if no matching field exists within this table.
+     * Use {@link getFieldIfExists} instead if you are unsure whether a field 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 getFieldById} or {@link getFieldByName} methods
+     * instead.
+     *
+     * @param fieldIdOrName The ID or name of the field you're looking for.
+     */
+  }, {
+    key: "getField",
+    value: function getField(fieldIdOrName) {
+      var field = this.getFieldIfExists(fieldIdOrName);
+      if (!field) {
+        throw (0, _error_utils.spawnError)("No field with ID or name '%s' in table '%s'", fieldIdOrName, this.name);
+      }
+      return field;
+    }
+    /** @internal */
+  }, {
+    key: "_cellValuesByFieldIdOrNameToCellValuesByFieldId",
+    value: function _cellValuesByFieldIdOrNameToCellValuesByFieldId(cellValuesByFieldIdOrName) {
+      return Object.fromEntries((0, _private_utils.entries)(cellValuesByFieldIdOrName).map(_ref => {
+        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+          fieldIdOrName = _ref2[0],
+          cellValue = _ref2[1];
+        var field = this.__getFieldMatching(fieldIdOrName);
+        return [field.id, cellValue];
+      }));
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__getFieldMatching",
+    value: function __getFieldMatching(fieldOrFieldIdOrFieldName) {
+      var field;
+      if (fieldOrFieldIdOrFieldName instanceof _field_core.FieldCore) {
+        if (fieldOrFieldIdOrFieldName.parentTable.id !== this.id) {
+          throw (0, _error_utils.spawnError)("Field '%s' is from a different table than table '%s'", fieldOrFieldIdOrFieldName.name, this.name);
+        }
+        field = fieldOrFieldIdOrFieldName;
+      } else {
+        field = this.getFieldByIdIfExists(fieldOrFieldIdOrFieldName) || this.getFieldByNameIfExists(fieldOrFieldIdOrFieldName);
+        if (field === null) {
+          throw (0, _error_utils.spawnError)("Field '%s' does not exist in table '%s'", fieldOrFieldIdOrFieldName, this.name);
+        }
+      }
+      if (field.isDeleted) {
+        throw (0, _error_utils.spawnError)("Field '%s' was deleted from table '%s'", field.name, this.name);
+      }
+      return field;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__triggerOnChangeForDirtyPaths",
+    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      var didTableSchemaChange = false;
+      if (dirtyPaths.name) {
+        this._onChange(WatchableTableKeysCore.name);
+        didTableSchemaChange = true;
+      }
+      if (dirtyPaths.lock) {
+        didTableSchemaChange = true;
+      }
+      if (dirtyPaths.externalSyncById) {
+        didTableSchemaChange = true;
+      }
+      if (dirtyPaths.description) {
+        this._onChange(WatchableTableKeysCore.description);
+        didTableSchemaChange = true;
+      }
+      if (dirtyPaths.fieldsById) {
+        // TODO: don't trigger schema change when autonumber typeOptions change.
+        // That currently happens every time you create a row in a table with an
+        // autonumber field.
+        didTableSchemaChange = true;
+
+        // Since tables don't have a field order, need to detect if a field
+        // was created or deleted and trigger onChange for fields.
+        var addedFieldIds = [];
+        var removedFieldIds = [];
+        var _iterator2 = _createForOfIteratorHelper((0, _private_utils.entries)(dirtyPaths.fieldsById)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
+              _fieldId3 = _step2$value[0],
+              dirtyFieldPaths = _step2$value[1];
+            if (dirtyFieldPaths && dirtyFieldPaths._isDirty) {
+              // If the entire field is dirty, it was either created or deleted.
+              if ((0, _private_utils.has)(this._data.fieldsById, _fieldId3)) {
+                addedFieldIds.push(_fieldId3);
+              } else {
+                removedFieldIds.push(_fieldId3);
+                var fieldModel = this._fieldModelsById[_fieldId3];
+                if (fieldModel) {
+                  // Remove the Field model if it was deleted.
+                  delete this._fieldModelsById[_fieldId3];
+                }
+              }
+            } else {
+              // Directly access from _fieldModelsById to avoid creating
+              // a field model if it doesn't already exist. If it doesn't exist,
+              // nothing can be subscribed to any events on it.
+              var field = this._fieldModelsById[_fieldId3];
+              if (field) {
+                field.__triggerOnChangeForDirtyPaths(dirtyFieldPaths);
+              }
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        if (addedFieldIds.length > 0 || removedFieldIds.length > 0) {
+          this._onChange(WatchableTableKeysCore.fields, {
+            addedFieldIds,
+            removedFieldIds
+          });
+        }
+
+        // Clear out cached field names in case a field was added/removed/renamed.
+        this._cachedFieldNamesById = null;
+      }
+
+      // NOTE: Record store onChange triggers must be performed AFTER field onChange triggers to
+      // ensure the column type providers are not stale.
+      this._recordStore.triggerOnChangeForDirtyPaths(dirtyPaths);
+      return didTableSchemaChange;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__getFieldNamesById",
+    value: function __getFieldNamesById() {
+      if (!this._cachedFieldNamesById) {
+        var fieldNamesById = {};
+        var _iterator3 = _createForOfIteratorHelper((0, _private_utils.entries)(this._data.fieldsById)),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _step3$value = (0, _slicedToArray2.default)(_step3.value, 2),
+              _fieldId4 = _step3$value[0],
+              fieldData = _step3$value[1];
+            fieldNamesById[_fieldId4] = fieldData.name;
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+        this._cachedFieldNamesById = fieldNamesById;
+      }
+      return this._cachedFieldNamesById;
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableTableKeysCore, key);
+    }
+  }]);
+}(_abstract_model.default);
+/** @internal */
+(0, _defineProperty2.default)(TableCore, "_className", 'TableCore');