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

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

@@ -1,13 +1,7 @@
-"use strict";
+import { isEnumValue, entries, isDeepEqual, has } from '../private_utils';
+import { spawnError, invariant } from '../error_utils';
+import AbstractModel from './abstract_model';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WatchableBaseKeys = exports.BaseCore = void 0;
-var _private_utils = require("../private_utils");
-var _error_utils = require("../error_utils");
-var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // How these model classes work:
 //
 // The single instance of the Base class maintains a reference to a plain JS
@@ -22,7 +16,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 // since the block developer could mutate it and we'll end up out of sync with
 // liveapp.
 
-const WatchableBaseKeys = exports.WatchableBaseKeys = Object.freeze({
+export const WatchableBaseKeys = Object.freeze({
   name: 'name',
   tables: 'tables',
   collaborators: 'collaborators',
@@ -43,12 +37,12 @@ const WatchableBaseKeys = exports.WatchableBaseKeys = Object.freeze({
 /** @internal */
 
 /** @hidden */
-class BaseCore extends _abstract_model.default {
+export class BaseCore extends AbstractModel {
   /** @internal */
   static _className = 'BaseCore';
   /** @internal */
   static _isWatchableKey(key) {
-    return (0, _private_utils.isEnumValue)(WatchableBaseKeys, key);
+    return isEnumValue(WatchableBaseKeys, key);
   }
   /** @internal */
 
@@ -196,7 +190,7 @@ class BaseCore extends _abstract_model.default {
    */
   getCollaboratorByIdIfExists(collaboratorId) {
     const collaboratorsById = this._data.collaboratorsById;
-    return (0, _private_utils.has)(collaboratorsById, collaboratorId) ? collaboratorsById[collaboratorId] : null;
+    return has(collaboratorsById, collaboratorId) ? collaboratorsById[collaboratorId] : null;
   }
   /**
    * The user matching the given ID. Throws if that user does not exist
@@ -209,7 +203,7 @@ class BaseCore extends _abstract_model.default {
   getCollaboratorById(collaboratorId) {
     const collaborator = this.getCollaboratorByIdIfExists(collaboratorId);
     if (!collaborator) {
-      throw (0, _error_utils.spawnError)("No collaborator with ID %s has access to base '%s'", collaboratorId, this.name);
+      throw spawnError("No collaborator with ID %s has access to base '%s'", collaboratorId, this.name);
     }
     return collaborator;
   }
@@ -232,7 +226,7 @@ class BaseCore extends _abstract_model.default {
       for (const [id, {
         email,
         name
-      }] of (0, _private_utils.entries)(this._data.collaboratorsById)) {
+      }] of entries(this._data.collaboratorsById)) {
         this._collaboratorIdsByNameAndEmail.set(email, id);
         // we prevent `@` in names so theoretically we shouldn't encounter any collisions
         // between names and emails, but names themselves may not be unique. as we build the
@@ -262,7 +256,7 @@ class BaseCore extends _abstract_model.default {
   getCollaborator(idOrNameOrEmail) {
     const collaborator = this.getCollaboratorIfExists(idOrNameOrEmail);
     if (!collaborator) {
-      throw (0, _error_utils.spawnError)("No collaborator with ID, name, or email of '%s' is in base '%s'", idOrNameOrEmail, this.name);
+      throw spawnError("No collaborator with ID, name, or email of '%s' is in base '%s'", idOrNameOrEmail, this.name);
     }
     return collaborator;
   }
@@ -297,7 +291,7 @@ class BaseCore extends _abstract_model.default {
   getTableById(tableId) {
     const table = this.getTableByIdIfExists(tableId);
     if (!table) {
-      throw (0, _error_utils.spawnError)("No table with ID %s in base '%s'", tableId, this.name);
+      throw spawnError("No table with ID %s in base '%s'", tableId, this.name);
     }
     return table;
   }
@@ -307,7 +301,7 @@ class BaseCore extends _abstract_model.default {
    * @param tableName The name of the table you're looking for.
    */
   getTableByNameIfExists(tableName) {
-    for (const [tableId, tableData] of (0, _private_utils.entries)(this._data.tablesById)) {
+    for (const [tableId, tableData] of entries(this._data.tablesById)) {
       if (tableData.name === tableName) {
         return this.getTableByIdIfExists(tableId);
       }
@@ -324,7 +318,7 @@ class BaseCore extends _abstract_model.default {
   getTableByName(tableName) {
     const table = this.getTableByNameIfExists(tableName);
     if (!table) {
-      throw (0, _error_utils.spawnError)("No table named '%s' in base '%s'", tableName, this.name);
+      throw spawnError("No table named '%s' in base '%s'", tableName, this.name);
     }
     return table;
   }
@@ -355,7 +349,7 @@ class BaseCore extends _abstract_model.default {
   getTable(tableIdOrName) {
     const table = this.getTableIfExists(tableIdOrName);
     if (!table) {
-      throw (0, _error_utils.spawnError)("No table with ID or name '%s' in base '%s'", tableIdOrName, this.name);
+      throw spawnError("No table with ID or name '%s' in base '%s'", tableIdOrName, this.name);
     }
     return table;
   }
@@ -371,10 +365,10 @@ class BaseCore extends _abstract_model.default {
    * @internal
    */
   __getRecordStore(tableId) {
-    if ((0, _private_utils.has)(this._tableRecordStoresByTableId, tableId)) {
+    if (has(this._tableRecordStoresByTableId, tableId)) {
       return this._tableRecordStoresByTableId[tableId];
     }
-    (0, _error_utils.invariant)(this._data.tablesById[tableId], 'table must exist');
+    invariant(this._data.tablesById[tableId], 'table must exist');
     const newRecordStore = this._constructRecordStore(this._sdk, tableId);
     this._tableRecordStoresByTableId[tableId] = newRecordStore;
     return newRecordStore;
@@ -397,7 +391,7 @@ class BaseCore extends _abstract_model.default {
       tablesById
     } = changedPaths;
     if (tablesById) {
-      if ((0, _private_utils.isDeepEqual)(tablesById, {
+      if (isDeepEqual(tablesById, {
         _isDirty: true
       })) {
         // If the changedPath is that tablesById is dirty in general, we need to
@@ -406,7 +400,7 @@ class BaseCore extends _abstract_model.default {
         // changing. See https://github.com/Hyperbase/hyperbase/blob/b50a8992d333bcef3c906d61886fc69727a8e94b/client/components/blocks/block_frame.tsx#L645
         didSchemaChange = true;
       } else {
-        for (const [tableId, dirtyTablePaths] of (0, _private_utils.entries)(tablesById)) {
+        for (const [tableId, dirtyTablePaths] of entries(tablesById)) {
           const table = this.getTableByIdIfExists(tableId);
           if (table && dirtyTablePaths) {
             const didTableSchemaChange = table.__triggerOnChangeForDirtyPaths(dirtyTablePaths);
@@ -460,11 +454,11 @@ class BaseCore extends _abstract_model.default {
       if (!dirtySubtree[part]) {
         dirtySubtree[part] = {};
       }
-      (0, _error_utils.invariant)(dirtySubtree[part], 'dirtySubtree');
+      invariant(dirtySubtree[part], 'dirtySubtree');
       dirtySubtree = dirtySubtree[part];
     }
     const lastPathPart = path[path.length - 1];
-    const didChange = !(0, _private_utils.isDeepEqual)(dataSubtree[lastPathPart], value);
+    const didChange = !isDeepEqual(dataSubtree[lastPathPart], value);
     if (value === undefined) {
       delete dataSubtree[lastPathPart];
     } else {
@@ -474,9 +468,8 @@ class BaseCore extends _abstract_model.default {
       if (!dirtySubtree[lastPathPart]) {
         dirtySubtree[lastPathPart] = {};
       }
-      (0, _error_utils.invariant)(dirtySubtree[lastPathPart], 'dirtySubtree');
+      invariant(dirtySubtree[lastPathPart], 'dirtySubtree');
       dirtySubtree[lastPathPart]._isDirty = true;
     }
   }
-}
-exports.BaseCore = BaseCore;
+}

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;
+}