@airtable/blocks 0.0.0-experimental-e5ab33b68-20250905 → 0.0.0-experimental-e625869e5-20251002

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

@@ -1,24 +1,16 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getLinkedTableId = exports.default = void 0;
-var _field_core = require("../../shared/types/field_core");
-var _error_utils = require("../../shared/error_utils");
-var _record_query_result = _interopRequireDefault(require("./record_query_result"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /** @module @airtable/blocks/models: RecordQueryResult */ /** */
-
-const getLinkedTableId = field => {
+import { FieldType } from '../../shared/types/field_core';
+import { invariant } from '../../shared/error_utils';
+import RecordQueryResult from './record_query_result';
+export const getLinkedTableId = field => {
   const options = field.options;
   const linkedTableId = options && options.linkedTableId;
-  (0, _error_utils.invariant)(typeof linkedTableId === 'string', 'linkedTableId must exist');
+  invariant(typeof linkedTableId === 'string', 'linkedTableId must exist');
   return linkedTableId;
 };
 
 /** internal */
-exports.getLinkedTableId = getLinkedTableId;
+
 /**
  * Represents a set of records from a LinkedRecord cell value. See {@link RecordQueryResult} for main
  * documentation.
@@ -28,7 +20,7 @@ exports.getLinkedTableId = getLinkedTableId;
  *
  * @docsPath models/query results/LinkedRecordsQueryResult
  */
-class LinkedRecordsQueryResult extends _record_query_result.default {
+class LinkedRecordsQueryResult extends RecordQueryResult {
   /** @internal */
   static _className = 'LinkedRecordsQueryResult';
 
@@ -69,7 +61,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
   /** @internal */
   constructor(record, field, normalizedOpts, sdk) {
     super(sdk, normalizedOpts);
-    (0, _error_utils.invariant)(record.parentTable === field.parentTable, 'record and field must belong to the same table');
+    invariant(record.parentTable === field.parentTable, 'record and field must belong to the same table');
     this._record = record;
     this._field = field;
     this._linkedTable = normalizedOpts.table;
@@ -102,7 +94,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
    * @internal (since we may not be able to return parent model instances in the immutable models world)
    */
   get parentTable() {
-    (0, _error_utils.invariant)(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
+    invariant(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
     return this._linkedTable;
   }
 
@@ -110,12 +102,12 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
    * Ordered array of all the linked record ids. Watchable.
    */
   get recordIds() {
-    (0, _error_utils.invariant)(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
-    (0, _error_utils.invariant)(this.isDataLoaded, 'LinkedRecordsQueryResult data is not loaded');
+    invariant(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
+    invariant(this.isDataLoaded, 'LinkedRecordsQueryResult data is not loaded');
 
     // record ids are lazily generated
     this._generateComputedDataIfNeeded();
-    (0, _error_utils.invariant)(this._computedFilteredSortedRecordIds, 'no recordIds');
+    invariant(this._computedFilteredSortedRecordIds, 'no recordIds');
     return this._computedFilteredSortedRecordIds;
   }
 
@@ -123,10 +115,10 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
    * Ordered array of all the linked records. Watchable.
    */
   get records() {
-    (0, _error_utils.invariant)(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
+    invariant(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
     return this.recordIds.map(recordId => {
       const record = this._linkedRecordStore.getRecordByIdIfExists(recordId);
-      (0, _error_utils.invariant)(record, 'No record for id: %s', recordId);
+      invariant(record, 'No record for id: %s', recordId);
       return record;
     });
   }
@@ -135,20 +127,20 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
    * The fields that were used to create this LinkedRecordsQueryResult.
    */
   get fields() {
-    (0, _error_utils.invariant)(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
+    invariant(this.isValid, 'LinkedRecordsQueryResult is no longer valid');
     return this._linkedQueryResult.fields;
   }
 
   /** @inheritdoc */
   watch(keys, callback, context) {
-    (0, _error_utils.invariant)(this.isValid, 'cannot watch an invalid LinkedRecordsQueryResult');
+    invariant(this.isValid, 'cannot watch an invalid LinkedRecordsQueryResult');
     const validKeys = super.watch(keys, callback, context);
     for (const key of validKeys) {
-      if (key === _record_query_result.default.WatchableKeys.cellValues) {
+      if (key === RecordQueryResult.WatchableKeys.cellValues) {
         this._watchLinkedQueryCellValuesIfNeededAfterWatch();
       }
-      if (key.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
-        const fieldId = key.substring(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix.length);
+      if (key.startsWith(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix)) {
+        const fieldId = key.substring(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix.length);
         this._watchLinkedQueryCellValuesInFieldIfNeededAfterWatch(fieldId);
       }
     }
@@ -159,11 +151,11 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
   unwatch(keys, callback, context) {
     const arrayKeys = Array.isArray(keys) ? keys : [keys];
     for (const key of arrayKeys) {
-      if (key === _record_query_result.default.WatchableKeys.cellValues) {
+      if (key === RecordQueryResult.WatchableKeys.cellValues) {
         this._unwatchLinkedQueryCellValuesIfPossibleBeforeUnwatch();
       }
-      if (key.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
-        const fieldId = key.substring(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix.length);
+      if (key.startsWith(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix)) {
+        const fieldId = key.substring(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix.length);
         this._unwatchLinkedQueryCellValuesInFieldIfPossibleBeforeUnwatch(fieldId);
       }
     }
@@ -206,7 +198,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
     }
     const fieldIds = this._normalizedOpts.fieldIdsOrNullIfAllFields || this.parentTable.fields.map(field => field.id);
     for (const fieldId of fieldIds) {
-      changedKeys.push(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
+      changedKeys.push(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix + fieldId);
     }
     return changedKeys;
   }
@@ -238,7 +230,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
 
   /** @internal */
   get _cellValuesWatchCount() {
-    return (this._changeWatchersByKey[_record_query_result.default.WatchableKeys.cellValues] || []).length;
+    return (this._changeWatchersByKey[RecordQueryResult.WatchableKeys.cellValues] || []).length;
   }
 
   /** @internal */
@@ -259,10 +251,10 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
   get _cellValueWatchCountByFieldId() {
     const countByFieldId = {};
     const watchKeys = Object.keys(this._changeWatchersByKey).filter(key => {
-      return key.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix);
+      return key.startsWith(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix);
     });
     for (const watchKey of watchKeys) {
-      const fieldId = watchKey.slice(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix.length);
+      const fieldId = watchKey.slice(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix.length);
       countByFieldId[fieldId] = this._changeWatchersByKey[watchKey].length;
     }
     return countByFieldId;
@@ -277,7 +269,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
 
   /** @internal */
   _unwatchLinkedQueryCellValuesInFieldIfPossibleBeforeUnwatch(fieldId) {
-    (0, _error_utils.invariant)(this._cellValueWatchCountByFieldId[fieldId], "cellValuesInField:%s over-free'd", fieldId);
+    invariant(this._cellValueWatchCountByFieldId[fieldId], "cellValuesInField:%s over-free'd", fieldId);
     if (this._cellValueWatchCountByFieldId[fieldId] === 1 && this.isValid) {
       this._unwatchLinkedQueryCellValuesInField(fieldId);
     }
@@ -335,12 +327,12 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
 
   /** @internal */
   _watchLinkedQueryCellValuesInField(fieldId) {
-    this._linkedQueryResult.watch(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, this._getOnLinkedCellValuesInFieldChange(fieldId), this);
+    this._linkedQueryResult.watch(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix + fieldId, this._getOnLinkedCellValuesInFieldChange(fieldId), this);
   }
 
   /** @internal */
   _unwatchLinkedQueryCellValuesInField(fieldId) {
-    this._linkedQueryResult.unwatch(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, this._getOnLinkedCellValuesInFieldChange(fieldId), this);
+    this._linkedQueryResult.unwatch(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix + fieldId, this._getOnLinkedCellValuesInFieldChange(fieldId), this);
   }
 
   /** @internal */
@@ -353,7 +345,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
       // records while keeping the behavior of isValid consistent
       return;
     }
-    (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+    invariant(this.isValid, 'watch key change event whilst invalid');
     this._invalidateComputedData();
 
     // we don't actually know at this stage whether anything changed or
@@ -379,7 +371,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
 
   /** @internal */
   _onLinkedCellValuesChange(queryResult, key, changes) {
-    (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+    invariant(this.isValid, 'watch key change event whilst invalid');
     if (changes && changes.fieldIds && changes.recordIds) {
       const recordIdsSet = this._getOrGenerateRecordIdsSet();
       const recordIds = changes.recordIds.filter(id => recordIdsSet[id] === true);
@@ -398,7 +390,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
   _getOnLinkedCellValuesInFieldChange(fieldId) {
     if (!this._cellValueChangeHandlerByFieldId[fieldId]) {
       this._cellValueChangeHandlerByFieldId[fieldId] = (queryResult, key, recordIds) => {
-        (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+        invariant(this.isValid, 'watch key change event whilst invalid');
 
         // The linked record may finish loading before its parent. In
         // that case, the appropriate events will be triggered by the
@@ -420,10 +412,10 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
           const recordIdsSet = this._getOrGenerateRecordIdsSet();
           const filteredRecordIds = recordIds.filter(id => typeof id === 'string' && recordIdsSet[id] === true);
           if (filteredRecordIds.length) {
-            this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, filteredRecordIds);
+            this._onChange(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix + fieldId, filteredRecordIds);
           }
         } else {
-          this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
+          this._onChange(RecordQueryResult.WatchableCellValuesInFieldKeyPrefix + fieldId);
         }
       };
     }
@@ -440,7 +432,7 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
       // records while keeping the behavior of isValid consistent
       return;
     }
-    (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+    invariant(this.isValid, 'watch key change event whilst invalid');
 
     // when the origin cell value (listing all the linked records) changes,
     // invalidate all the data we have stored - we need to completely
@@ -468,9 +460,9 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
 
   /** @internal */
   _onOriginFieldConfigChange() {
-    (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+    invariant(this.isValid, 'watch key change event whilst invalid');
     const type = this._field.type;
-    if (type !== _field_core.FieldType.MULTIPLE_RECORD_LINKS) {
+    if (type !== FieldType.MULTIPLE_RECORD_LINKS) {
       this._invalidateQueryResult();
       return;
     }
@@ -515,11 +507,11 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
     const recordIdsSet = {};
     const rawCellValue = this._record.getCellValue(this._field);
     const cellValue = rawCellValue === null ? [] : rawCellValue;
-    (0, _error_utils.invariant)(Array.isArray(cellValue), 'cellValue should be array');
+    invariant(Array.isArray(cellValue), 'cellValue should be array');
     for (const linkedRecord of cellValue) {
-      (0, _error_utils.invariant)(linkedRecord && typeof linkedRecord === 'object', 'linked record should be object');
+      invariant(linkedRecord && typeof linkedRecord === 'object', 'linked record should be object');
       const recordId = linkedRecord.id;
-      (0, _error_utils.invariant)(typeof recordId === 'string', 'id should be present');
+      invariant(typeof recordId === 'string', 'id should be present');
 
       // We need to use the query result as the source of truth for
       // recordIds, since when the client deletes a record from the linked
@@ -546,8 +538,8 @@ class LinkedRecordsQueryResult extends _record_query_result.default {
   _getOrGenerateRecordIdsSet() {
     this._generateComputedDataIfNeeded();
     const recordIdsSet = this._computedRecordIdsSet;
-    (0, _error_utils.invariant)(recordIdsSet, 'recordIdsSet must exist');
+    invariant(recordIdsSet, 'recordIdsSet must exist');
     return recordIdsSet;
   }
 }
-var _default = exports.default = LinkedRecordsQueryResult;
+export default LinkedRecordsQueryResult;

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

@@ -0,0 +1,19 @@
+// istanbul ignore file
+/** @ignore */ /** */
+import '../assert_run_context';
+import * as recordColoring from './record_coloring';
+export { FieldType } from '../../shared/types/field_core';
+export { ViewType } from '../types/view';
+export { default as Base } from './base';
+export { default as Table } from './table';
+export { default as Field } from './field';
+export { default as View } from './view';
+export { default as Record } from './record';
+export { default as RecordQueryResult } from './record_query_result';
+export { default as TableOrViewQueryResult } from './table_or_view_query_result';
+export { default as GroupedRecordQueryResult } from './grouped_record_query_result';
+export { default as LinkedRecordsQueryResult } from './linked_records_query_result';
+export { default as ViewMetadataQueryResult } from './view_metadata_query_result';
+export { default as Session } from './session';
+export { default as Cursor } from './cursor';
+export { recordColoring };

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

@@ -1,16 +1,10 @@
-"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");
+import { BlockRunContextType } from '../types/airtable_interface';
+import { MutationTypes } from '../types/mutations';
+import { spawnError, spawnUnknownSwitchCaseError } from '../../shared/error_utils';
+import { MAX_FIELD_NAME_LENGTH, MAX_FIELD_DESCRIPTION_LENGTH, MAX_TABLE_NAME_LENGTH, MAX_NUM_FIELDS_PER_TABLE } from '../../shared/types/mutation_constants';
+import { MutationsCore } from '../../shared/models/mutations_core';
 /** @hidden */
-class Mutations extends _mutations_core.MutationsCore {
+class Mutations extends MutationsCore {
   /** @internal */
   _isRecordStoreReadyForMutations(recordStore) {
     return recordStore.isRecordMetadataLoaded;
@@ -43,15 +37,15 @@ class Mutations extends _mutations_core.MutationsCore {
     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:
+      case MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case MutationTypes.CREATE_MULTIPLE_RECORDS:
+      case MutationTypes.DELETE_MULTIPLE_RECORDS:
         {
           super._assertMutationIsValid(mutation);
           return;
         }
-      case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
+      case MutationTypes.CREATE_SINGLE_FIELD:
         {
           const {
             tableId,
@@ -61,24 +55,24 @@ class Mutations extends _mutations_core.MutationsCore {
           } = 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);
+            throw 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);
+          if (table.fields.length >= MAX_NUM_FIELDS_PER_TABLE) {
+            throw spawnError("Can't create field: table already has the maximum of %s fields", 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);
+            throw 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);
+          if (description && description.length > MAX_FIELD_DESCRIPTION_LENGTH) {
+            throw spawnError("Can't create field: description exceeds maximum length of %s characters", MAX_FIELD_DESCRIPTION_LENGTH);
           }
           return;
         }
-      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+      case MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
         {
           const {
             tableId,
@@ -88,11 +82,11 @@ class Mutations extends _mutations_core.MutationsCore {
           } = 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);
+            throw 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);
+            throw 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
@@ -101,11 +95,11 @@ class Mutations extends _mutations_core.MutationsCore {
           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);
+            throw spawnError("Can't update field: invalid field config.\n%s", validationResult.reason);
           }
           return;
         }
-      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+      case MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
         {
           const {
             tableId,
@@ -114,18 +108,18 @@ class Mutations extends _mutations_core.MutationsCore {
           } = 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);
+            throw 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);
+            throw 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);
+          if (description && description.length > MAX_FIELD_DESCRIPTION_LENGTH) {
+            throw spawnError("Can't update field: description exceeds maximum length of %s characters", MAX_FIELD_DESCRIPTION_LENGTH);
           }
           return;
         }
-      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+      case MutationTypes.UPDATE_SINGLE_FIELD_NAME:
         {
           const {
             tableId,
@@ -134,11 +128,11 @@ class Mutations extends _mutations_core.MutationsCore {
           } = 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);
+            throw 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);
+            throw spawnError("Can't update field: No field with id %s exists", id);
           }
 
           // We skip name validation if it's the same name:
@@ -149,58 +143,58 @@ class Mutations extends _mutations_core.MutationsCore {
           }
           return;
         }
-      case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
+      case MutationTypes.CREATE_SINGLE_TABLE:
         {
           const {
             name,
             fields
           } = mutation;
           if (!name) {
-            throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name");
+            throw 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);
+          if (name.length > MAX_TABLE_NAME_LENGTH) {
+            throw spawnError("Can't create table: name '%s' exceeds maximum length of %s characters", name, 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);
+            throw 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");
+            throw 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);
+          if (fields.length > MAX_NUM_FIELDS_PER_TABLE) {
+            throw spawnError("Can't create table: number of fields exceeds maximum of %s", 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");
+              throw 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);
+            if (field.name.length > MAX_FIELD_NAME_LENGTH) {
+              throw spawnError("Can't create table: field name '%s' exceeds maximum length of %s characters", field.name, 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);
+              throw 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);
+              throw 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);
+            if (field.description && field.description.length > MAX_FIELD_DESCRIPTION_LENGTH) {
+              throw spawnError("Can't create table: description for field '%s' exceeds maximum length of %s characters", field.name, 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);
+            throw 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:
+      case MutationTypes.UPDATE_VIEW_METADATA:
         {
           const {
             tableId,
@@ -209,50 +203,50 @@ class Mutations extends _mutations_core.MutationsCore {
           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.type !== BlockRunContextType.VIEW) {
+            throw 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');
+            throw 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);
+            throw 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);
+            throw spawnError("Can't update metadata: No view with id %s exists", viewId);
           }
           return;
         }
       default:
-        throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
+        throw 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");
+      throw 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);
+    if (name.length > MAX_FIELD_NAME_LENGTH) {
+      throw spawnError("Can't create or update field: name '%s' exceeds maximum length of %s characters", name, 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);
+      throw 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:
+      case MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
         return super._getOptimisticModelChangesForMutation(mutation);
-      case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+      case MutationTypes.CREATE_MULTIPLE_RECORDS:
         {
           const {
             tableId,
@@ -271,7 +265,7 @@ class Mutations extends _mutations_core.MutationsCore {
             return viewDataStore.__generateChangesForParentTableAddMultipleRecords(records.map(record => record.id));
           })];
         }
-      case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
+      case MutationTypes.DELETE_MULTIPLE_RECORDS:
         {
           const {
             tableId,
@@ -290,12 +284,12 @@ class Mutations extends _mutations_core.MutationsCore {
             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:
+      case MutationTypes.CREATE_SINGLE_FIELD:
+      case MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+      case MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+      case MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+      case MutationTypes.UPDATE_VIEW_METADATA:
+      case MutationTypes.CREATE_SINGLE_TABLE:
         {
           // No optimistic updates for field, view metadata, or table mutations.
           return [];
@@ -305,8 +299,8 @@ class Mutations extends _mutations_core.MutationsCore {
       // call site is preceded by an explicit guard for this condition.
       // istanbul ignore next
       default:
-        throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
+        throw spawnUnknownSwitchCaseError('mutation type', mutation, 'type');
     }
   }
 }
-var _default = exports.default = Mutations;
+export default Mutations;

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

@@ -1,12 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _error_utils = require("../../shared/error_utils");
 /** @hidden */ /** */
-
+import { invariant } from '../../shared/error_utils';
 const WEAK_RETAIN_TIME_MS = 10000;
 class ObjectPool {
   /** @internal */
@@ -37,9 +30,9 @@ class ObjectPool {
   unregisterObjectForReuseStrong(object) {
     const objectKey = object.__poolKey;
     const pooledObjects = this._objectsByKey[objectKey];
-    (0, _error_utils.invariant)(pooledObjects, 'pooledObjects');
+    invariant(pooledObjects, 'pooledObjects');
     const index = pooledObjects.indexOf(object);
-    (0, _error_utils.invariant)(index !== -1, 'object not registered');
+    invariant(index !== -1, 'object not registered');
     pooledObjects.splice(index, 1);
     if (pooledObjects.length === 0) {
       // `delete` causes de-opts, which slows down subsequent reads,
@@ -142,4 +135,4 @@ class ObjectPool {
     return newObject;
   }
 }
-var _default = exports.default = ObjectPool;
+export default ObjectPool;