@airtable/blocks 0.0.0-experimental-e5ab33b68-20250905 → 0.0.0-experimental-3e47d4d04-20250909

package/dist/{cjs → esm}/shared/models/field_core.js

@@ -1,13 +1,7 @@
-"use strict";
+import { FieldType } from '../types/field_core';
+import { isEnumValue, cloneDeep } from '../private_utils';
+import AbstractModel from './abstract_model';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.FieldCore = void 0;
-var _field_core = require("../types/field_core");
-var _private_utils = require("../private_utils");
-var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // This doesn't follow our enum naming conventions because we want the keys
 // to mirror the method/getter names on the model class.
 const WatchableFieldKeys = Object.freeze({
@@ -29,12 +23,12 @@ const WatchableFieldKeys = Object.freeze({
  */
 
 /** @hidden */
-class FieldCore extends _abstract_model.default {
+export class FieldCore extends AbstractModel {
   /** @internal */
   static _className = 'FieldCore';
   /** @internal */
   static _isWatchableKey(key) {
-    return (0, _private_utils.isEnumValue)(WatchableFieldKeys, key);
+    return isEnumValue(WatchableFieldKeys, key);
   }
   /** @internal */
 
@@ -99,7 +93,7 @@ class FieldCore extends _abstract_model.default {
     // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.
     // @ts-ignore
     if (type === 'lookup') {
-      return _field_core.FieldType.MULTIPLE_LOOKUP_VALUES;
+      return FieldType.MULTIPLE_LOOKUP_VALUES;
     } else {
       return type;
     }
@@ -129,7 +123,7 @@ class FieldCore extends _abstract_model.default {
     // TODO: In the next breaking release freeze (inside of the cache) and replace
     // FieldOptions with readonly<FieldOptions>.
     // Today this is required because we re-use the fieldTypeProvider.getConfig response.
-    return options ? (0, _private_utils.cloneDeep)(options) : null;
+    return options ? cloneDeep(options) : null;
   }
 
   // We use a cached response from FieldTypeProvider because getting the config can
@@ -239,7 +233,7 @@ class FieldCore extends _abstract_model.default {
     // The opt parseDateCellValueInColumnTimeZone is used here to ensure date string
     // inputs are interpreted correctly according to the `timeZone` of the dateTime field.
     {
-      parseDateCellValueInColumnTimeZone: this.type === _field_core.FieldType.DATE_TIME
+      parseDateCellValueInColumnTimeZone: this.type === FieldType.DATE_TIME
     });
 
     // Temporarily bail out of validating computed values (since validation will crash)
@@ -284,5 +278,4 @@ class FieldCore extends _abstract_model.default {
       this._onChange(WatchableFieldKeys.isFieldSynced);
     }
   }
-}
-exports.FieldCore = FieldCore;
+}

package/dist/{cjs → esm}/shared/models/mutations_core.js

@@ -1,17 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.MutationsCore = exports.MUTATIONS_MAX_BATCH_SIZE = void 0;
-var _mutations_core = require("../types/mutations_core");
-var _error_utils = require("../error_utils");
-var _private_utils = require("../private_utils");
+import { MutationTypesCore } from '../types/mutations_core';
+import { spawnError } from '../error_utils';
+import { entries } from '../private_utils';
 // Limit for how many items can be updated from a single batch mutation.
 // This is number of records for MULTIPLE_RECORDS type mutations, and number of global config paths
 // for SET_MULTIPLE_GLOBAL_CONFIG_PATHS.
 // Same limit is enforced liveapp-side
-const MUTATIONS_MAX_BATCH_SIZE = exports.MUTATIONS_MAX_BATCH_SIZE = 50;
+export const MUTATIONS_MAX_BATCH_SIZE = 50;
 
 // Liveapp requests must be under 2mb in size: we enforce a 1.9mb limit here to allow space for
 // the other parts of the request
@@ -19,7 +13,7 @@ const MUTATIONS_MAX_BODY_SIZE = 1.9 * 1024 * 1024;
 const MUTATION_HOLD_FOR_MS = 100;
 
 /** @hidden */
-class MutationsCore {
+export class MutationsCore {
   /** @internal */
 
   /** @internal */
@@ -51,7 +45,7 @@ class MutationsCore {
     this._assertMutationUnderLimits(mutation);
     const permissionCheck = this.checkPermissionsForMutation(mutation);
     if (!permissionCheck.hasPermission) {
-      throw (0, _error_utils.spawnError)('Cannot apply %s mutation: %s', mutation.type, permissionCheck.reasonDisplayString);
+      throw spawnError('Cannot apply %s mutation: %s', mutation.type, permissionCheck.reasonDisplayString);
     }
     const didApplyOptimisticUpdates = this._applyOptimisticUpdatesForMutation(mutation);
     try {
@@ -95,10 +89,10 @@ class MutationsCore {
     // - mutation payload size won't exceed liveapp request payload size limit
     // Requests are sent as form-encoded utf-8 (1 byte characters)
     if (encodeURIComponent(JSON.stringify(mutation)).length > MUTATIONS_MAX_BODY_SIZE) {
-      throw (0, _error_utils.spawnError)('Request exceeds maximum size limit of %s bytes', MUTATIONS_MAX_BODY_SIZE);
+      throw spawnError('Request exceeds maximum size limit of %s bytes', MUTATIONS_MAX_BODY_SIZE);
     }
     if (this._doesMutationExceedBatchSizeLimit(mutation)) {
-      throw (0, _error_utils.spawnError)('Request exceeds maximum batch size limit of %s items', MUTATIONS_MAX_BATCH_SIZE);
+      throw spawnError('Request exceeds maximum batch size limit of %s items', MUTATIONS_MAX_BATCH_SIZE);
     }
   }
 
@@ -107,7 +101,7 @@ class MutationsCore {
     // GlobalConfig updates are different to other mutations (on models): for models, we
     // only apply optimistic updates if the relevant models are loaded, whereas for
     // SET_MULTIPLE_GLOBAL_CONFIG_PATHS we always apply optimistic updates.
-    if (mutation.type === _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS) {
+    if (mutation.type === MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS) {
       // Not sure why this cast is necessary, but TS complains without it.
       const _mutation = mutation;
       this._applyGlobalConfigUpdates(_mutation.updates);
@@ -124,12 +118,12 @@ class MutationsCore {
   /** @internal */
   _doesMutationExceedBatchSizeLimit(mutation) {
     switch (mutation.type) {
-      case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
-      case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
+      case MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case MutationTypesCore.CREATE_MULTIPLE_RECORDS:
         return mutation.records.length > MUTATIONS_MAX_BATCH_SIZE;
-      case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
+      case MutationTypesCore.DELETE_MULTIPLE_RECORDS:
         return mutation.recordIds.length > MUTATIONS_MAX_BATCH_SIZE;
-      case _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
         return mutation.updates.length > MUTATIONS_MAX_BATCH_SIZE;
       // The "default" case cannot be reached because this method is only
       // invoked after the mutation type has been validated.
@@ -142,7 +136,7 @@ class MutationsCore {
   /** @internal */
   _assertFieldIsValidForMutation(field) {
     if (field.isComputed) {
-      throw (0, _error_utils.spawnError)("Can't set cell values: Field '%s' is computed and cannot be set", field.name);
+      throw spawnError("Can't set cell values: Field '%s' is computed and cannot be set", field.name);
     }
   }
 
@@ -159,7 +153,7 @@ class MutationsCore {
 
     const appInterface = this._sdk.__appInterface;
     switch (mutation.type) {
-      case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
         {
           const {
             tableId,
@@ -167,7 +161,7 @@ class MutationsCore {
           } = mutation;
           const table = this._base.getTableByIdIfExists(tableId);
           if (!table) {
-            throw (0, _error_utils.spawnError)("Can't set cell values: No table with id %s exists", tableId);
+            throw spawnError("Can't set cell values: No table with id %s exists", tableId);
           }
 
           // For every mutation, we check that we're not trying to set fields that we don't support
@@ -180,13 +174,13 @@ class MutationsCore {
             if (this._isRecordStoreReadyForMutations(recordStore)) {
               existingRecord = recordStore.getRecordByIdIfExists(record.id);
               if (!existingRecord) {
-                throw (0, _error_utils.spawnError)("Can't set cell values: No record with id %s exists", record.id);
+                throw spawnError("Can't set cell values: No record with id %s exists", record.id);
               }
             }
             for (const fieldId of Object.keys(record.cellValuesByFieldId)) {
               const field = table.getFieldByIdIfExists(fieldId);
               if (!field) {
-                throw (0, _error_utils.spawnError)("Can't set cell values: No field with id %s exists in table '%s'", fieldId, table.name);
+                throw spawnError("Can't set cell values: No field with id %s exists in table '%s'", fieldId, table.name);
               }
               if (!checkedFieldIds.has(fieldId)) {
                 this._assertFieldIsValidForMutation(field);
@@ -195,14 +189,14 @@ class MutationsCore {
               if (existingRecord && this._isFieldAvailableForMutation(recordStore, field.id)) {
                 const validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.cellValuesByFieldId[fieldId], existingRecord._getRawCellValue(field), field._data);
                 if (!validationResult.isValid) {
-                  throw (0, _error_utils.spawnError)("Can't set cell values: invalid cell value for field '%s'.\n%s", field.name, validationResult.reason);
+                  throw spawnError("Can't set cell values: invalid cell value for field '%s'.\n%s", field.name, validationResult.reason);
                 }
               }
             }
           }
           return;
         }
-      case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
+      case MutationTypesCore.DELETE_MULTIPLE_RECORDS:
         {
           const {
             tableId,
@@ -210,20 +204,20 @@ class MutationsCore {
           } = mutation;
           const table = this._base.getTableByIdIfExists(tableId);
           if (!table) {
-            throw (0, _error_utils.spawnError)("Can't delete records: No table with id %s exists", tableId);
+            throw spawnError("Can't delete records: No table with id %s exists", tableId);
           }
           const recordStore = this._base.__getRecordStore(tableId);
           if (this._isRecordStoreReadyForMutations(recordStore)) {
             for (const recordId of recordIds) {
               const record = recordStore.getRecordByIdIfExists(recordId);
               if (!record) {
-                throw (0, _error_utils.spawnError)("Can't delete records: No record with id %s exists in table '%s'", recordId, table.name);
+                throw spawnError("Can't delete records: No record with id %s exists in table '%s'", recordId, table.name);
               }
             }
           }
           return;
         }
-      case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
+      case MutationTypesCore.CREATE_MULTIPLE_RECORDS:
         {
           const {
             tableId,
@@ -232,13 +226,13 @@ class MutationsCore {
           const checkedFieldIds = new Set();
           const table = this._base.getTableByIdIfExists(tableId);
           if (!table) {
-            throw (0, _error_utils.spawnError)("Can't create records: No table with id %s exists", tableId);
+            throw spawnError("Can't create records: No table with id %s exists", tableId);
           }
           for (const record of records) {
             for (const fieldId of Object.keys(record.cellValuesByFieldId)) {
               const field = table.getFieldByIdIfExists(fieldId);
               if (!field) {
-                throw (0, _error_utils.spawnError)("Can't create records: No field with id %s exists in table '%s'", fieldId, table.name);
+                throw spawnError("Can't create records: No field with id %s exists in table '%s'", fieldId, table.name);
               }
               if (!checkedFieldIds.has(fieldId)) {
                 this._assertFieldIsValidForMutation(field);
@@ -248,13 +242,13 @@ class MutationsCore {
               // Current cell value is null since the record doesn't exist.
               const validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.cellValuesByFieldId[fieldId], null, field._data);
               if (!validationResult.isValid) {
-                throw (0, _error_utils.spawnError)("Can't create records: invalid cell value for field '%s'.\n%s", field.name, validationResult.reason);
+                throw spawnError("Can't create records: invalid cell value for field '%s'.\n%s", field.name, validationResult.reason);
               }
             }
           }
           return;
         }
-      case _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
         {
           // globalConfig update is a special case: globalConfig handles validation before
           // invoking this mutation, since it relies on internal state to validate the
@@ -262,14 +256,14 @@ class MutationsCore {
           return;
         }
       default:
-        throw (0, _error_utils.spawnError)('unhandled mutation type: %s', mutation.type);
+        throw spawnError('unhandled mutation type: %s', mutation.type);
     }
   }
 
   /** @internal */
   _getOptimisticModelChangesForMutation(mutation) {
     switch (mutation.type) {
-      case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
         {
           const {
             tableId,
@@ -281,7 +275,7 @@ class MutationsCore {
             value: record.cellValuesByFieldId[fieldId]
           })));
         }
-      case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
+      case MutationTypesCore.DELETE_MULTIPLE_RECORDS:
         {
           const {
             tableId,
@@ -292,7 +286,7 @@ class MutationsCore {
             value: undefined
           }));
         }
-      case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
+      case MutationTypesCore.CREATE_MULTIPLE_RECORDS:
         {
           const {
             tableId,
@@ -302,7 +296,7 @@ class MutationsCore {
           return records.map(record => {
             // Only apply optimistic changes for fields that are "available" for mutation
             const filteredCellValuesByFieldId = {};
-            for (const [fieldId, cellValue] of (0, _private_utils.entries)(record.cellValuesByFieldId)) {
+            for (const [fieldId, cellValue] of entries(record.cellValuesByFieldId)) {
               if (this._isFieldAvailableForMutation(recordStore, fieldId)) {
                 filteredCellValuesByFieldId[fieldId] = cellValue;
               }
@@ -321,16 +315,16 @@ class MutationsCore {
       // The following branch is unreachable because this method's only
       // call site is preceded by an explicit guard for this condition.
       // istanbul ignore next
-      case _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
         {
-          throw (0, _error_utils.spawnError)('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
+          throw spawnError('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
         }
 
       // 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.spawnError)('unhandled mutation type: %s', mutation.type);
+        throw spawnError('unhandled mutation type: %s', mutation.type);
     }
   }
 
@@ -339,5 +333,4 @@ class MutationsCore {
   /** @internal */
 
   /** @internal */
-}
-exports.MutationsCore = MutationsCore;
+}

package/dist/{cjs → esm}/shared/models/record_core.js

@@ -1,16 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WatchableRecordKeysCore = exports.RecordCore = void 0;
-var _private_utils = require("../private_utils");
-var _error_utils = require("../error_utils");
-var _field_core = require("../types/field_core");
-var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-var _field_core2 = require("./field_core");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const WatchableRecordKeysCore = exports.WatchableRecordKeysCore = Object.freeze({
+import { cloneDeep, isEnumValue, isObjectEmpty } from '../private_utils';
+import { invariant } from '../error_utils';
+import { FieldType } from '../types/field_core';
+import AbstractModel from './abstract_model';
+import { FieldCore } from './field_core';
+export const WatchableRecordKeysCore = Object.freeze({
   name: 'name',
   // TODO(kasra): these keys don't have matching getters (not that they should
   // it's just inconsistent...)
@@ -20,12 +13,12 @@ const WatchableRecordKeysCore = exports.WatchableRecordKeysCore = Object.freeze(
 /** @hidden */
 
 /** @hidden */
-class RecordCore extends _abstract_model.default {
+export class RecordCore extends AbstractModel {
   /** @internal */
   static _className = 'RecordCore';
   /** @internal */
   static _isWatchableKey(key) {
-    return (0, _private_utils.isEnumValue)(WatchableRecordKeysCore, key);
+    return isEnumValue(WatchableRecordKeysCore, key);
   }
   /** @internal */
 
@@ -49,7 +42,7 @@ class RecordCore extends _abstract_model.default {
       return null;
     }
     const recordsById = tableData.recordsById;
-    (0, _error_utils.invariant)(recordsById, 'Record data is not loaded');
+    invariant(recordsById, 'Record data is not loaded');
     return recordsById[this._id] ?? null;
   }
 
@@ -72,7 +65,7 @@ class RecordCore extends _abstract_model.default {
    * @internal
    */
   _getFieldMatching(fieldOrFieldIdOrFieldName) {
-    if (fieldOrFieldIdOrFieldName instanceof _field_core2.FieldCore) {
+    if (fieldOrFieldIdOrFieldName instanceof FieldCore) {
       return this._parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName.id);
     }
     return this.parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName);
@@ -97,7 +90,7 @@ class RecordCore extends _abstract_model.default {
     if (typeof cellValue === 'object' && cellValue !== null) {
       // Copy non-primitives.
       // TODO(kasra): maybe freezeDeep instead?
-      return (0, _private_utils.cloneDeep)(cellValue);
+      return cloneDeep(cellValue);
     } else {
       return cellValue;
     }
@@ -118,15 +111,15 @@ class RecordCore extends _abstract_model.default {
     const cellValue = this._getRawCellValue(field);
 
     // HACK: migrate to new public lookup cell value format if needed
-    if (typeof cellValue === 'object' && cellValue !== null && field.type === _field_core.FieldType.MULTIPLE_LOOKUP_VALUES && !this._sdk.__airtableInterface.sdkInitData.isUsingNewLookupCellValueFormat) {
+    if (typeof cellValue === 'object' && cellValue !== null && field.type === FieldType.MULTIPLE_LOOKUP_VALUES && !this._sdk.__airtableInterface.sdkInitData.isUsingNewLookupCellValueFormat) {
       const cellValueForMigration = [];
-      (0, _error_utils.invariant)(Array.isArray(cellValue.linkedRecordIds), 'linkedRecordIds');
+      invariant(Array.isArray(cellValue.linkedRecordIds), 'linkedRecordIds');
       for (const linkedRecordId of cellValue.linkedRecordIds) {
-        (0, _error_utils.invariant)(typeof linkedRecordId === 'string', 'linkedRecordId');
+        invariant(typeof linkedRecordId === 'string', 'linkedRecordId');
         const {
           valuesByLinkedRecordId
         } = cellValue;
-        (0, _error_utils.invariant)(valuesByLinkedRecordId && typeof valuesByLinkedRecordId === 'object', 'valuesByLinkedRecordId');
+        invariant(valuesByLinkedRecordId && typeof valuesByLinkedRecordId === 'object', 'valuesByLinkedRecordId');
         const value = valuesByLinkedRecordId[linkedRecordId];
         if (Array.isArray(value)) {
           for (const v of value) {
@@ -200,7 +193,7 @@ class RecordCore extends _abstract_model.default {
     const {
       cellValuesByFieldId
     } = dirtyPaths;
-    if (cellValuesByFieldId && !(0, _private_utils.isObjectEmpty)(cellValuesByFieldId)) {
+    if (cellValuesByFieldId && !isObjectEmpty(cellValuesByFieldId)) {
       // TODO: don't trigger changes for fields that aren't supposed to be loaded
       // (in some cases, e.g. record created, liveapp will send cell values
       // that we're not subscribed to).
@@ -211,5 +204,4 @@ class RecordCore extends _abstract_model.default {
       }
     }
   }
-}
-exports.RecordCore = RecordCore;
+}

package/dist/{cjs → esm}/shared/models/record_store_core.js

@@ -1,19 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.WatchableRecordStoreKeysCore = exports.WatchableCellValuesInFieldKeyPrefix = void 0;
-var _private_utils = require("../../shared/private_utils");
-var _error_utils = require("../../shared/error_utils");
-var _abstract_model = _interopRequireDefault(require("../../shared/models/abstract_model"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const WatchableRecordStoreKeysCore = exports.WatchableRecordStoreKeysCore = Object.freeze({
+import { isEnumValue, entries, has } from '../../shared/private_utils';
+import { invariant } from '../../shared/error_utils';
+import AbstractModel from '../../shared/models/abstract_model';
+export const WatchableRecordStoreKeysCore = Object.freeze({
   records: 'records',
   recordIds: 'recordIds',
   cellValues: 'cellValues'
 });
-const WatchableCellValuesInFieldKeyPrefix = exports.WatchableCellValuesInFieldKeyPrefix = 'cellValuesInField:';
+export const WatchableCellValuesInFieldKeyPrefix = 'cellValuesInField:';
 
 /**
  * The string case is to accommodate prefix keys
@@ -27,10 +20,10 @@ const WatchableCellValuesInFieldKeyPrefix = exports.WatchableCellValuesInFieldKe
  *
  * @internal
  */
-class RecordStoreCore extends _abstract_model.default {
+class RecordStoreCore extends AbstractModel {
   static _className = 'RecordStoreCore';
   static _isWatchableKey(key) {
-    return (0, _private_utils.isEnumValue)(WatchableRecordStoreKeysCore, key) || key.startsWith(WatchableCellValuesInFieldKeyPrefix);
+    return isEnumValue(WatchableRecordStoreKeysCore, key) || key.startsWith(WatchableCellValuesInFieldKeyPrefix);
   }
   _recordModelsById = {};
   constructor(sdk, tableId) {
@@ -54,10 +47,10 @@ class RecordStoreCore extends _abstract_model.default {
    */
   get records() {
     const recordsById = this._data.recordsById;
-    (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+    invariant(recordsById, 'Record metadata is not loaded');
     const records = this.recordIds.map(recordId => {
       const record = this.getRecordByIdIfExists(recordId);
-      (0, _error_utils.invariant)(record, 'record');
+      invariant(record, 'record');
       return record;
     });
     return records;
@@ -69,8 +62,8 @@ class RecordStoreCore extends _abstract_model.default {
 
   getRecordByIdIfExists(recordId) {
     const recordsById = this._data.recordsById;
-    (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
-    (0, _error_utils.invariant)(typeof recordId === 'string', 'getRecordById expects a string');
+    invariant(recordsById, 'Record metadata is not loaded');
+    invariant(typeof recordId === 'string', 'getRecordById expects a string');
     if (!recordsById[recordId]) {
       return null;
     } else {
@@ -89,11 +82,11 @@ class RecordStoreCore extends _abstract_model.default {
       const dirtyFieldIdsSet = {};
       const addedRecordIds = [];
       const removedRecordIds = [];
-      for (const [recordId, dirtyRecordPaths] of (0, _private_utils.entries)(dirtyPaths.recordsById)) {
+      for (const [recordId, dirtyRecordPaths] of entries(dirtyPaths.recordsById)) {
         if (dirtyRecordPaths && dirtyRecordPaths._isDirty) {
           // If the entire record is dirty, it was either created or deleted.
-          (0, _error_utils.invariant)(this._data.recordsById, 'No recordsById');
-          if ((0, _private_utils.has)(this._data.recordsById, recordId)) {
+          invariant(this._data.recordsById, 'No recordsById');
+          if (has(this._data.recordsById, recordId)) {
             addedRecordIds.push(recordId);
           } else {
             removedRecordIds.push(recordId);
@@ -157,4 +150,4 @@ class RecordStoreCore extends _abstract_model.default {
 }
 
 /** @internal */
-var _default = exports.default = RecordStoreCore;
+export default RecordStoreCore;

package/dist/{cjs → esm}/shared/models/session_core.js

@@ -1,14 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SessionCore = void 0;
-var _error_utils = require("../error_utils");
-var _private_utils = require("../private_utils");
-var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /** @module @airtable/blocks/models: Session */ /** */
+import { invariant } from '../error_utils';
+import { isEnumValue, entries } from '../private_utils';
+import AbstractModel from './abstract_model';
 
 /** @hidden */
 
@@ -25,12 +18,12 @@ const WatchableSessionKeys = Object.freeze({
  */
 
 /** @hidden */
-class SessionCore extends _abstract_model.default {
+export class SessionCore extends AbstractModel {
   /** @internal */
   static _className = 'SessionCore';
   /** @internal */
   static _isWatchableKey(key) {
-    return (0, _private_utils.isEnumValue)(WatchableSessionKeys, key);
+    return isEnumValue(WatchableSessionKeys, key);
   }
   /** @internal */
 
@@ -127,14 +120,14 @@ class SessionCore extends _abstract_model.default {
       value
     } of changes) {
       if (path[0] === 'permissionLevel') {
-        (0, _error_utils.invariant)(path.length === 1, 'cannot set within permissionLevel');
+        invariant(path.length === 1, 'cannot set within permissionLevel');
 
         // NOTE: just verify that the permission level is a string (rather than
         // checking isEnumValue against PermissionLevels) in case new permission
         // levels are added on the liveapp side. Permissions behavior gets routed
         // through the checkPermissionsForMutation AirtableInterface helper, so we
         // should still be able to handle unknown permission levels.
-        (0, _error_utils.invariant)(typeof value === 'string', 'permissionLevel must be a string');
+        invariant(typeof value === 'string', 'permissionLevel must be a string');
         this._sessionData.permissionLevel = value;
         changedKeys[WatchableSessionKeys.permissionLevel] = true;
       }
@@ -150,11 +143,10 @@ class SessionCore extends _abstract_model.default {
    * @internal
    */
   __triggerOnChangeForChangedKeys(changedKeys) {
-    for (const [key, didChange] of (0, _private_utils.entries)(changedKeys)) {
+    for (const [key, didChange] of entries(changedKeys)) {
       if (didChange) {
         this._onChange(key);
       }
     }
   }
-}
-exports.SessionCore = SessionCore;
+}