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

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

@@ -1,119 +1,94 @@
 "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 */ /** */
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @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) {
+class AbstractModel extends _watchable.default {
+  /** @internal */
+  static _className = 'AbstractModel';
+  /**
+   * 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
+  static _isWatchableKey(key) {
+    // Override to return whether `key` is a valid watchable key.
+    return false;
+  }
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   /**
    * @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;
+  constructor(sdk, modelId) {
+    super();
+    (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;
   }
   /**
    * 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;
+  get id() {
+    return this._id;
+  }
+  /**
+   * @internal
+   */
+
+  /**
+   * @internal
+   */
+  get _data() {
+    const data = this._dataOrNullIfDeleted;
+    if (data === null) {
+      throw this._spawnErrorForDeletion();
     }
-  }]);
-}(_watchable.default);
-/** @internal */
-(0, _defineProperty2.default)(AbstractModel, "_className", 'AbstractModel');
+    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.
+   */
+  get isDeleted() {
+    return this._dataOrNullIfDeleted === null;
+  }
+  /**
+   * @internal
+   */
+  _spawnErrorForDeletion() {
+    return (0, _error_utils.spawnError)('%s has been deleted', this.constructor._className);
+  }
+  /**
+   * A string representation of the model for use in debugging.
+   */
+  toString() {
+    return `[${this.constructor._className} ${this.id}]`;
+  }
+}
 var _default = exports.default = AbstractModel;