@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-3649c7162-20250904

package/dist/{cjs → esm}/base/models/models.js

@@ -1,107 +1,102 @@
 "use strict";
 
-require("core-js/modules/es.array.iterator.js");
-require("core-js/modules/es.object.to-string.js");
-require("core-js/modules/es.weak-map.js");
-require("core-js/modules/web.dom-collections.iterator.js");
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "Base", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _base.default;
   }
 });
 Object.defineProperty(exports, "Cursor", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _cursor.default;
   }
 });
 Object.defineProperty(exports, "Field", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _field.default;
   }
 });
 Object.defineProperty(exports, "FieldConfig", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _field_core.FieldConfig;
   }
 });
 Object.defineProperty(exports, "FieldType", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _field_core.FieldType;
   }
 });
 Object.defineProperty(exports, "GroupedRecordQueryResult", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _grouped_record_query_result.default;
   }
 });
 Object.defineProperty(exports, "LinkedRecordsQueryResult", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _linked_records_query_result.default;
   }
 });
 Object.defineProperty(exports, "Record", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _record.default;
   }
 });
 Object.defineProperty(exports, "RecordQueryResult", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _record_query_result.default;
   }
 });
 Object.defineProperty(exports, "Session", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _session.default;
   }
 });
 Object.defineProperty(exports, "Table", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _table.default;
   }
 });
 Object.defineProperty(exports, "TableOrViewQueryResult", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _table_or_view_query_result.default;
   }
 });
 Object.defineProperty(exports, "View", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _view2.default;
   }
 });
 Object.defineProperty(exports, "ViewMetadataQueryResult", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _view_metadata_query_result.default;
   }
 });
 Object.defineProperty(exports, "ViewType", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _view.ViewType;
   }
 });
 exports.recordColoring = void 0;
+require("../assert_run_context");
 var recordColoring = _interopRequireWildcard(require("./record_coloring"));
 exports.recordColoring = recordColoring;
-var _create_aggregators = _interopRequireDefault(require("./create_aggregators"));
 var _field_core = require("../../shared/types/field_core");
 var _view = require("../types/view");
 var _base = _interopRequireDefault(require("./base"));
@@ -116,22 +111,6 @@ var _linked_records_query_result = _interopRequireDefault(require("./linked_reco
 var _view_metadata_query_result = _interopRequireDefault(require("./view_metadata_query_result"));
 var _session = _interopRequireDefault(require("./session"));
 var _cursor = _interopRequireDefault(require("./cursor"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-// istanbul ignore file
-/** @ignore */ /** */
-
-// HACK: aggregators need airtable_interface to initialize - really, they should be a property of
-// base instead of here. to work around that, they're initialized lazily for now:
-// eslint-disable-next-line no-var
-
-var initializedAggregators = null;
-Object.defineProperty(exports, 'aggregators', {
-  enumerable: true,
-  get: () => {
-    if (!initializedAggregators) {
-      initializedAggregators = (0, _create_aggregators.default)();
-    }
-    return initializedAggregators;
-  }
-});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/dist/esm/base/models/mutations.js

@@ -0,0 +1,312 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _airtable_interface = require("../types/airtable_interface");
+var _mutations = require("../types/mutations");
+var _error_utils = require("../../shared/error_utils");
+var _mutation_constants = require("../../shared/types/mutation_constants");
+var _mutations_core = require("../../shared/models/mutations_core");
+/** @hidden */
+class Mutations extends _mutations_core.MutationsCore {
+  /** @internal */
+  _isRecordStoreReadyForMutations(recordStore) {
+    return recordStore.isRecordMetadataLoaded;
+  }
+
+  /** @internal */
+  _isFieldAvailableForMutation(recordStore, fieldId) {
+    return recordStore.areCellValuesLoadedForFieldId(fieldId);
+  }
+
+  /** @internal */
+  _getDefaultRecordProperties() {
+    return {
+      commentCount: 0,
+      createdTime: new Date().toJSON()
+    };
+  }
+
+  /** @internal */
+  _assertMutationIsValid(mutation) {
+    // We call validate the data (including any cell values) because if the data required for
+    // us to do that is already loaded in the block, we can error out before applying
+    // optimistic updates or sending the update to liveapp. That means that the error is
+    // recoverable. Once we apply optimistic updates, if liveapp rejects the update then we
+    // can't recover from that - we have to crash the block. We _could_ skip over these
+    // validations - it wouldn't cause issues outside of the block frame. But running them
+    // gives us slightly more confidence that we can do something other than completely crash
+    // the block in the event of an invalid mutation.
+
+    const appInterface = this._sdk.__appInterface;
+    const billingPlanGrouping = this._base.__billingPlanGrouping;
+    switch (mutation.type) {
+      case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+      case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
+        {
+          super._assertMutationIsValid(mutation);
+          return;
+        }
+      case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
+        {
+          const {
+            tableId,
+            name,
+            config,
+            description
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't create field: No table with id %s exists", tableId);
+          }
+          if (table.fields.length >= _mutation_constants.MAX_NUM_FIELDS_PER_TABLE) {
+            throw (0, _error_utils.spawnError)("Can't create field: table already has the maximum of %s fields", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
+          }
+          this._assertFieldNameIsValidForMutation(name, table);
+
+          // Current config / field data is null since the field doesn't exist.
+          const validationResult = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, config, null, null, billingPlanGrouping);
+          if (!validationResult.isValid) {
+            throw (0, _error_utils.spawnError)("Can't create field: invalid field config.\n%s", validationResult.reason);
+          }
+          if (description && description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+            throw (0, _error_utils.spawnError)("Can't create field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+        {
+          const {
+            tableId,
+            id,
+            config,
+            opts
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", tableId);
+          }
+          const field = table.getFieldByIdIfExists(id);
+          if (!field) {
+            throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", id);
+          }
+
+          // we get the config directly instead of using field.type/field.options to get it
+          // in one call and because field.options returns null instead of undefined when
+          // a field does not have options, whilst we need to pass undefined
+          const currentConfig = this._airtableInterface.fieldTypeProvider.getConfig(appInterface, field._data, field.parentTable.__getFieldNamesById());
+          const validationResult = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, config, currentConfig, field._data, billingPlanGrouping, opts);
+          if (!validationResult.isValid) {
+            throw (0, _error_utils.spawnError)("Can't update field: invalid field config.\n%s", validationResult.reason);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+        {
+          const {
+            tableId,
+            id,
+            description
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", tableId);
+          }
+          const field = table.getFieldByIdIfExists(id);
+          if (!field) {
+            throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", id);
+          }
+          if (description && description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+            throw (0, _error_utils.spawnError)("Can't update field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+        {
+          const {
+            tableId,
+            id,
+            name
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", tableId);
+          }
+          const field = table.getFieldByIdIfExists(id);
+          if (!field) {
+            throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", id);
+          }
+
+          // We skip name validation if it's the same name:
+          // If it's exactly same name, this will result in no-op;
+          // If it's only case change, we allow update and we know this name is already validated before;
+          if (field.name.toLowerCase() !== name.toLowerCase()) {
+            this._assertFieldNameIsValidForMutation(name, table);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
+        {
+          const {
+            name,
+            fields
+          } = mutation;
+          if (!name) {
+            throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name");
+          }
+          if (name.length > _mutation_constants.MAX_TABLE_NAME_LENGTH) {
+            throw (0, _error_utils.spawnError)("Can't create table: name '%s' exceeds maximum length of %s characters", name, _mutation_constants.MAX_TABLE_NAME_LENGTH);
+          }
+          const existingLowercaseTableNames = this._base.tables.map(table => table.name.toLowerCase());
+          if (existingLowercaseTableNames.includes(name.toLowerCase())) {
+            throw (0, _error_utils.spawnError)("Can't create table: table with name '%s' already exists", name);
+          }
+          if (fields.length === 0) {
+            throw (0, _error_utils.spawnError)("Can't create table: must specify at least one field");
+          }
+          if (fields.length > _mutation_constants.MAX_NUM_FIELDS_PER_TABLE) {
+            throw (0, _error_utils.spawnError)("Can't create table: number of fields exceeds maximum of %s", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
+          }
+          const lowercaseFieldNames = new Set();
+          for (const field of fields) {
+            if (!field.name) {
+              throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name for every field");
+            }
+            if (field.name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
+              throw (0, _error_utils.spawnError)("Can't create table: field name '%s' exceeds maximum length of %s characters", field.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+            }
+            const lowercaseFieldName = field.name.toLowerCase();
+            if (lowercaseFieldNames.has(lowercaseFieldName)) {
+              throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", field.name);
+            }
+            lowercaseFieldNames.add(lowercaseFieldName);
+
+            // Current config / field data is null since the field doesn't exist.
+            const validationResult = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, field.config, null, null, billingPlanGrouping);
+            if (!validationResult.isValid) {
+              throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", field.name, validationResult.reason);
+            }
+            if (field.description && field.description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+              throw (0, _error_utils.spawnError)("Can't create table: description for field '%s' exceeds maximum length of %s characters", field.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+            }
+          }
+          const primaryField = fields[0];
+          if (!this._airtableInterface.fieldTypeProvider.canBePrimary(appInterface, primaryField.config, billingPlanGrouping)) {
+            throw (0, _error_utils.spawnError)("Can't create table: first field '%s' has type '%s' which cannot be a primary field", primaryField.name, primaryField.config.type);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
+        {
+          const {
+            tableId,
+            viewId
+          } = mutation;
+          const {
+            runContext
+          } = this._airtableInterface.sdkInitData;
+          if (runContext.type !== _airtable_interface.BlockRunContextType.VIEW) {
+            throw (0, _error_utils.spawnError)('Setting view metadata is only valid for views');
+          }
+          if (runContext.viewId !== viewId || runContext.tableId !== tableId) {
+            throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
+          }
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", tableId);
+          }
+          const view = table.getViewByIdIfExists(viewId);
+          if (!view) {
+            throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);
+          }
+          return;
+        }
+      default:
+        throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
+    }
+  }
+
+  /** @internal */
+  _assertFieldNameIsValidForMutation(name, table) {
+    if (!name) {
+      throw (0, _error_utils.spawnError)("Can't create or update field: must provide non-empty name");
+    }
+    if (name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
+      throw (0, _error_utils.spawnError)("Can't create or update field: name '%s' exceeds maximum length of %s characters", name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+    }
+
+    // Verify the new name doesn't collide with any existing field name.
+    const existingLowercaseFieldNames = table.fields.map(field => field.name.toLowerCase());
+    if (existingLowercaseFieldNames.includes(name.toLowerCase())) {
+      throw (0, _error_utils.spawnError)("Can't create or update field: field with name '%s' already exists", name);
+    }
+  }
+
+  /** @internal */
+  _getOptimisticModelChangesForMutation(mutation) {
+    switch (mutation.type) {
+      case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+        return super._getOptimisticModelChangesForMutation(mutation);
+      case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            records
+          } = mutation;
+          const recordStore = this._base.__getRecordStore(tableId);
+          if (!recordStore.isRecordMetadataLoaded) {
+            return [];
+          }
+          const superChanges = super._getOptimisticModelChangesForMutation(mutation);
+          return [...superChanges, ...this._base.getTableById(tableId).views.flatMap(view => {
+            const viewDataStore = recordStore.getViewDataStore(view.id);
+            if (!viewDataStore.isDataLoaded) {
+              return [];
+            }
+            return viewDataStore.__generateChangesForParentTableAddMultipleRecords(records.map(record => record.id));
+          })];
+        }
+      case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            recordIds
+          } = mutation;
+          const recordStore = this._base.__getRecordStore(tableId);
+          if (!recordStore.isRecordMetadataLoaded) {
+            return [];
+          }
+          const superChanges = super._getOptimisticModelChangesForMutation(mutation);
+          return [...superChanges, ...this._base.getTableById(tableId).views.flatMap(view => {
+            const viewDataStore = recordStore.getViewDataStore(view.id);
+            if (!viewDataStore.isDataLoaded) {
+              return [];
+            }
+            return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
+          })];
+        }
+      case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+      case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
+      case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
+        {
+          // No optimistic updates for field, view metadata, or table mutations.
+          return [];
+        }
+
+      // The following branch is unreachable because this method's only
+      // call site is preceded by an explicit guard for this condition.
+      // istanbul ignore next
+      default:
+        throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
+    }
+  }
+}
+var _default = exports.default = Mutations;

package/dist/esm/base/models/object_pool.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _error_utils = require("../../shared/error_utils");
+/** @hidden */ /** */
+
+const WEAK_RETAIN_TIME_MS = 10000;
+class ObjectPool {
+  /** @internal */
+  _objectsByKey = {};
+  /** @internal */
+  _weakObjectsByKey = {};
+  /** @internal */
+
+  /** @hidden */
+  constructor(ctor) {
+    this._Ctor = ctor;
+  }
+
+  // we have two different ways we can register an object for reuse - weak and strong. This one,
+  // strong, will make sure that the object is kept in the pool until it is explicitly removed.
+  /** @hidden */
+  registerObjectForReuseStrong(object) {
+    this._unregisterObjectForReuseWeakIfExists(object);
+    const objectKey = object.__poolKey;
+    const pooledObjects = this._objectsByKey[objectKey];
+    if (pooledObjects) {
+      pooledObjects.push(object);
+    } else {
+      this._objectsByKey[objectKey] = [object];
+    }
+  }
+  /** @hidden */
+  unregisterObjectForReuseStrong(object) {
+    const objectKey = object.__poolKey;
+    const pooledObjects = this._objectsByKey[objectKey];
+    (0, _error_utils.invariant)(pooledObjects, 'pooledObjects');
+    const index = pooledObjects.indexOf(object);
+    (0, _error_utils.invariant)(index !== -1, 'object not registered');
+    pooledObjects.splice(index, 1);
+    if (pooledObjects.length === 0) {
+      // `delete` causes de-opts, which slows down subsequent reads,
+      // so set to undefined instead (unverified that this is actually faster).
+      this._objectsByKey[objectKey] = undefined;
+    }
+  }
+
+  // we have two different ways we can register an object for reuse - weak and strong. This one,
+  // weak, will automatically unregister the object after a few seconds go by without it being
+  // used.
+  /** @hidden */
+  _registerObjectForReuseWeak(object) {
+    const objectKey = object.__poolKey;
+    const pooledObjects = this._weakObjectsByKey[objectKey];
+    const toStore = {
+      object,
+      timeoutId: setTimeout(() => this._unregisterObjectForReuseWeakIfExists(object), WEAK_RETAIN_TIME_MS)
+    };
+    if (pooledObjects) {
+      pooledObjects.push(toStore);
+    } else {
+      this._weakObjectsByKey[objectKey] = [toStore];
+    }
+  }
+  /** @internal */
+  _unregisterObjectForReuseWeakIfExists(object) {
+    const objectKey = object.__poolKey;
+    const pooledObjects = this._weakObjectsByKey[objectKey];
+    if (!pooledObjects) {
+      return false;
+    }
+    const index = pooledObjects.findIndex(stored => stored.object === object);
+    if (index === -1) {
+      return false;
+    }
+    const stored = pooledObjects[index];
+    clearTimeout(stored.timeoutId);
+    pooledObjects.splice(index, 1);
+    if (pooledObjects.length === 0) {
+      // `delete` causes de-opts, which slows down subsequent reads,
+      // so set to undefined instead (unverified that this is actually faster).
+      this._weakObjectsByKey[objectKey] = undefined;
+    }
+    return true;
+  }
+
+  /** @internal */
+  _getObjectForReuseStrong(key) {
+    const pooledObjects = this._objectsByKey[key];
+    if (pooledObjects) {
+      // We expect that there won't be too many QueryResults for a given
+      // model, so iterating over them should be okay. If this assumption
+      // ends up being wrong, we can hash the opts or something.
+      for (const object of pooledObjects) {
+        if (object.__poolKey === key) {
+          return object;
+        }
+      }
+    }
+    return null;
+  }
+  /** @internal */
+  _getObjectForReuseWeak(key) {
+    const pooledObjects = this._weakObjectsByKey[key];
+    if (!pooledObjects) {
+      return null;
+    }
+    const stored = pooledObjects.find(_ref => {
+      let {
+        object
+      } = _ref;
+      return object.__poolKey === key;
+    });
+    if (!stored) {
+      return null;
+    }
+    const {
+      object,
+      timeoutId
+    } = stored;
+
+    // reset the timer on this object if it's reused
+    clearTimeout(timeoutId);
+    stored.timeoutId = setTimeout(() => this._unregisterObjectForReuseWeakIfExists(object), WEAK_RETAIN_TIME_MS);
+    return object;
+  }
+  /** @hidden */
+  getObjectForReuse() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    const newObject = new this._Ctor(...args);
+    const key = newObject.__poolKey;
+    const existingObject = this._getObjectForReuseStrong(key) || this._getObjectForReuseWeak(key);
+    if (existingObject) {
+      return existingObject;
+    }
+    this._registerObjectForReuseWeak(newObject);
+    return newObject;
+  }
+}
+var _default = exports.default = ObjectPool;