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

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

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.concat.js");
+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 _watchable = _interopRequireDefault(require("../watchable"));
+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: Abstract models */ /** */
+/**
+ * Abstract superclass for all models. You won't use this class directly.
+ *
+ * @docsPath models/advanced/AbstractModel
+ */
+var AbstractModel = /*#__PURE__*/function (_Watchable) {
+  /**
+   * @internal
+   */
+  function AbstractModel(sdk, modelId) {
+    var _this;
+    (0, _classCallCheck2.default)(this, AbstractModel);
+    _this = _callSuper(this, AbstractModel);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_baseData", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_id", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_sdk", void 0);
+    (0, _error_utils.invariant)(typeof modelId === 'string', '%s id should be a string', _this.constructor._className);
+    _this._sdk = sdk;
+    _this._baseData = sdk.__airtableInterface.sdkInitData.baseData;
+    _this._id = modelId;
+    return _this;
+  }
+  /**
+   * The ID for this model.
+   */
+  (0, _inherits2.default)(AbstractModel, _Watchable);
+  return (0, _createClass2.default)(AbstractModel, [{
+    key: "id",
+    get: function get() {
+      return this._id;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "_data",
+    get:
+    /**
+     * @internal
+     */
+    function get() {
+      var data = this._dataOrNullIfDeleted;
+      if (data === null) {
+        throw this._spawnErrorForDeletion();
+      }
+      return data;
+    }
+    /**
+     * `true` if the model has been deleted, and `false` otherwise.
+     *
+     * In general, it's best to avoid keeping a reference to an object past the
+     * current event loop, since it may be deleted and trying to access any data
+     * of a deleted object (other than its ID) will throw. But if you keep a
+     * reference, you can use `isDeleted` to check that it's safe to access the
+     * model's data.
+     */
+  }, {
+    key: "isDeleted",
+    get: function get() {
+      return this._dataOrNullIfDeleted === null;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "_spawnErrorForDeletion",
+    value: function _spawnErrorForDeletion() {
+      return (0, _error_utils.spawnError)('%s has been deleted', this.constructor._className);
+    }
+    /**
+     * A string representation of the model for use in debugging.
+     */
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "[".concat(this.constructor._className, " ").concat(this.id, "]");
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value:
+    /**
+     * This method is essentially abstract, but as of this writing, TypeScript
+     * does not support abstract static methods. This necessitates a concrete
+     * implementation which must be explicitly ignored by the test coverage
+     * tooling.
+     *
+     * @internal
+     */
+    // istanbul ignore next
+    function _isWatchableKey(key) {
+      // Override to return whether `key` is a valid watchable key.
+      return false;
+    }
+  }]);
+}(_watchable.default);
+/** @internal */
+(0, _defineProperty2.default)(AbstractModel, "_className", 'AbstractModel');
+var _default = exports.default = AbstractModel;

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

@@ -0,0 +1,579 @@
+"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; })(); }
+// How these model classes work:
+//
+// The single instance of the Base class maintains a reference to a plain JS
+// object that contains all the data (baseData). All the other model classes
+// receive a reference to baseData and traverse it to expose the data.
+//
+// As changes come in from liveapp, Base will apply them to the plain JS object.
+// Since the other model classes have a reference to the same object, they'll
+// always be accessing the most up-to-date values.
+//
+// Be careful not to return a reference to any non-primitive subtree of baseData,
+// since the block developer could mutate it and we'll end up out of sync with
+// liveapp.
+
+var WatchableBaseKeys = exports.WatchableBaseKeys = Object.freeze({
+  name: 'name',
+  tables: 'tables',
+  collaborators: 'collaborators',
+  schema: 'schema',
+  color: 'color'
+});
+
+/**
+ * Any key in base that can be watched:
+ * - `name`: the name of the base
+ * - `tables`: the order of tables in the base
+ * - `collaborators`: all the collaborators in the base
+ * - `schema`: the base schema (essentially everything except for record data)
+ */
+
+/** @internal */
+
+/** @internal */
+/** @hidden */
+var BaseCore = exports.BaseCore = /*#__PURE__*/function (_AbstractModel) {
+  /**
+   * @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;
+  }
+
+  /**
+   * Aliased to communicate stability for internal use by Sdk code.
+   *
+   * @internal
+   */
+  (0, _inherits2.default)(BaseCore, _AbstractModel);
+  return (0, _createClass2.default)(BaseCore, [{
+    key: "__sdk",
+    get: function get() {
+      return this._sdk;
+    }
+
+    /**
+     * @internal
+     */
+  }, {
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      return this._baseData;
+    }
+    /**
+     * The name of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The name of your base is', base.name);
+     * ```
+     */
+  }, {
+    key: "name",
+    get: function get() {
+      return this._data.name;
+    }
+
+    /**
+     * The workspace id of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The workspace id of your base is', base.workspaceId);
+     * ```
+     */
+  }, {
+    key: "workspaceId",
+    get: function get() {
+      return this._data.workspaceId;
+    }
+
+    /**
+     * The color of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * import {Box} from '@airtable/blocks/ui';
+     * const exampleBox = <Box backgroundColor={base.color}> This box's background is the same color as the base background</Box>
+     * ```
+     */
+  }, {
+    key: "color",
+    get: function get() {
+      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 {base} from '@airtable/blocks';
+     * 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();
+      }
+      return tables;
+    }
+
+    /** @internal */
+  }, {
+    key: "activeCollaborators",
+    get:
+    /**
+     * The users who have access to this base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * 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;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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();
+        }
+      }
+      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;
+    }
+    /**
+     * 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];
+      }
+    }
+    /**
+     * 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 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.
+     */
+  }, {
+    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 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 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);
+    }
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * @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
+     */
+  }, {
+    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);
+        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;
+                }
+              }
+            }
+          } 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;
+    }
+    /**
+     * @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 (didChange) {
+        if (!dirtySubtree[lastPathPart]) {
+          dirtySubtree[lastPathPart] = {};
+        }
+        (0, _error_utils.invariant)(dirtySubtree[lastPathPart], 'dirtySubtree');
+        dirtySubtree[lastPathPart]._isDirty = true;
+      }
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableBaseKeys, key);
+    }
+  }]);
+}(_abstract_model.default);
+/** @internal */
+(0, _defineProperty2.default)(BaseCore, "_className", 'BaseCore');