@airtable/blocks 1.9.0 → 1.10.0-experimental-48096ae-20211116

package/dist/cjs/models/record.js

@@ -6,12 +6,20 @@ require("core-js/modules/es.symbol");
 
 require("core-js/modules/es.symbol.description");
 
+require("core-js/modules/es.array.concat");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.includes");
+
 require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.object.to-string");
 
 require("core-js/modules/es.promise");
 
+require("core-js/modules/es.string.includes");
+
 require("core-js/modules/es.string.starts-with");
 
 require("core-js/modules/web.dom-collections.iterator");
@@ -29,9 +37,11 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
@@ -47,6 +57,8 @@ var _error_utils = require("../error_utils");
 
 var _color_utils = _interopRequireDefault(require("../color_utils"));
 
+var _block_query_spec = require("../types/block_query_spec");
+
 var _abstract_model = _interopRequireDefault(require("./abstract_model"));
 
 var _object_pool = _interopRequireDefault(require("./object_pool"));
@@ -80,6 +92,23 @@ var WatchableColorInViewKeyPrefix = 'colorInView:';
  * - `'colorInView:' + someViewId`
  */
 
+function _isKeySubscribeableViaRecordQuery(key) {
+  switch (key) {
+    case WatchableRecordKeys.name:
+    case WatchableRecordKeys.commentCount:
+    case WatchableRecordKeys.cellValues:
+      return true;
+
+    default:
+      if (key.startsWith(WatchableCellValueInFieldKeyPrefix)) {
+        return true;
+      }
+
+      break;
+  }
+
+  return false;
+}
 /**
  * Model class representing a record in a table.
  *
@@ -88,6 +117,8 @@ var WatchableColorInViewKeyPrefix = 'colorInView:';
  *
  * @docsPath models/Record
  */
+
+
 var Record =
 /*#__PURE__*/
 function (_AbstractModel) {
@@ -115,9 +146,16 @@ function (_AbstractModel) {
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Record).call(this, sdk, recordId));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentRecordStore", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentTable", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryManager", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "__linkedRecordsQueryResultPool", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_onRecordColorChange", (viewDataStore, key, recordIds) => {
+      if (recordIds.includes(_this.id)) {
+        _this._onChange(WatchableColorInViewKeyPrefix + viewDataStore.viewId);
+      }
+    });
     _this._parentRecordStore = parentRecordStore;
     _this._parentTable = parentTable;
+    _this._queryManager = sdk._queryManager;
     _this.__linkedRecordsQueryResultPool = new _object_pool.default(_linked_records_query_result.default);
     return _this;
   }
@@ -127,6 +165,33 @@ function (_AbstractModel) {
 
 
   (0, _createClass2.default)(Record, [{
+    key: "_assertExistsAndLoaded",
+
+    /**
+     * @internal
+     */
+    value: function _assertExistsAndLoaded() {
+      // Access data in order to throw if the Record has been deleted / isn't loaded
+      var data = this._dataOrNullIfDeleted;
+
+      if (data === null) {
+        throw this._spawnErrorForDeletion();
+      }
+    }
+    /**
+     * The table that this record belongs to. Should never change because records aren't moved between tables.
+     *
+     * @internal (since we may not be able to return parent model instances in the immutable models world)
+     * @example
+     * ```js
+     * import {useRecords} from '@airtable/blocks/ui';
+     * const records = useRecords(myTable);
+     * console.log(records[0].parentTable.id === myTable.id);
+     * // => true
+     * ```
+     */
+
+  }, {
     key: "_getFieldMatching",
 
     /**
@@ -156,18 +221,20 @@ function (_AbstractModel) {
   }, {
     key: "_getRawCellValue",
     value: function _getRawCellValue(field) {
-      (0, _error_utils.invariant)(this._parentRecordStore.areCellValuesLoadedForFieldId(field.id), 'Cell values for field %s are not loaded', field.id);
-      var cellValuesByFieldId = this._data.cellValuesByFieldId;
+      this._assertExistsAndLoaded(); // TODO: (#proj-blocks-sdk-record-limits) Consider a new API that allows determining
+      // if the cell value is loaded + getting the cellValue in one call?
 
-      if (!cellValuesByFieldId) {
-        return null;
-      }
 
-      var cellValue = cellValuesByFieldId[field.id] !== undefined ? cellValuesByFieldId[field.id] : null;
+      var isCellValueLoadedForField = this._parentRecordStore.isRecordCellValueLoadedForFieldId(this._id, field.id);
+
+      (0, _error_utils.invariant)(isCellValueLoadedForField, 'Cell value for field %s and record %s is not loaded', field.id, this._id);
+
+      var cellValue = this._parentRecordStore.getRecordCellValueByFieldId(this._id, field.id);
 
       if (typeof cellValue === 'object' && cellValue !== null) {
         // Copy non-primitives.
-        // TODO(kasra): maybe freezeDeep instead?
+        // TODO: (#proj-blocks-sdk-record-limits): getRecordCellValueByFieldId returns
+        // deeply frozen objects, in a later sdk version we can drop cloning deeply.
         return (0, _private_utils.cloneDeep)(cellValue);
       } else {
         return cellValue;
@@ -278,9 +345,8 @@ function (_AbstractModel) {
   }, {
     key: "getCellValueAsString",
     value: function getCellValueAsString(fieldOrFieldIdOrFieldName) {
-      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName);
+      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName); // getRawCellValue performs invariant check that cell value at the field is loaded
 
-      (0, _error_utils.invariant)(this._parentRecordStore.areCellValuesLoadedForFieldId(field.id), 'Cell values for field %s are not loaded', field.id);
 
       var cellValue = this._getRawCellValue(field);
 
@@ -443,73 +509,256 @@ function (_AbstractModel) {
      */
 
   }, {
-    key: "__triggerOnChangeForDirtyPaths",
+    key: "_constructBlockFieldSelectionSpec",
 
     /**
      * @internal
      */
-    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
-      var cellValuesByFieldId = dirtyPaths.cellValuesByFieldId,
-          commentCount = dirtyPaths.commentCount;
-
-      if (cellValuesByFieldId && !(0, _private_utils.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).
-        this._onChange(WatchableRecordKeys.cellValues, Object.keys(cellValuesByFieldId));
-
-        if (cellValuesByFieldId[this.parentTable.primaryField.id]) {
-          this._onChange(WatchableRecordKeys.name);
+    value: function _constructBlockFieldSelectionSpec(fieldSelection) {
+      return {
+        sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
+        sourceTableId: this.parentTable.id,
+        recordSelection: {
+          recordIds: [this.id],
+          fieldSelection
         }
+      };
+    }
+    /**
+     * @internal
+     */
 
-        for (var _i = 0, _Object$keys = Object.keys(cellValuesByFieldId); _i < _Object$keys.length; _i++) {
-          var fieldId = _Object$keys[_i];
+  }, {
+    key: "_findMatchingBlockSubscriptionChanges",
+    value: function _findMatchingBlockSubscriptionChanges(changes, changeTypeToMatch) {
+      return changes.filter(change => change.type === changeTypeToMatch && change.tableId === this.parentTable.id);
+    }
+    /**
+     * @internal
+     */
+
+  }, {
+    key: "_constructBlockQuerySpecAndCallbackForWatchableKey",
+    value: function _constructBlockQuerySpecAndCallbackForWatchableKey(key, callbackForRegistration, context) {
+      var fieldSelectionDefinition;
+
+      var onChangeCallback = () => {
+        callbackForRegistration.call(context, this, key);
+      };
+
+      switch (key) {
+        case WatchableRecordKeys.name:
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+            fieldIds: [this.parentTable.primaryField.id]
+          };
+          break;
+
+        case WatchableRecordKeys.commentCount:
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+            fieldIds: [],
+            shouldIncludeCommentCount: true
+          };
+          break;
+
+        case WatchableRecordKeys.cellValues:
+          // TODO: (#proj-blocks-sdk-record-limits) In the future don't fetch all fields from table
+          // old code exhibit this behavior though: https://github.com/Hyperbase/blocks-sdk/blob/aba6fa7b7f8ccc1e364b409ca466d0281f8e9a69/packages/sdk/src/models/record.ts#L414-L416
+          // In the future a "subscribe to updates, but don't fetch more data" might be useful here.
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE
+          };
+
+          onChangeCallback = changes => {
+            var modifiedCellValuesChanges = this._findMatchingBlockSubscriptionChanges(changes, _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE); // We do not currently simulate "on load" callback for registration
+            // but still handle it.
+
+
+            if (modifiedCellValuesChanges.length === 0) {
+              callbackForRegistration.call(context, this, key);
+              return;
+            }
+
+            var fieldIdsModified = [];
+            var _iteratorNormalCompletion3 = true;
+            var _didIteratorError3 = false;
+            var _iteratorError3 = undefined;
+
+            try {
+              for (var _iterator3 = modifiedCellValuesChanges[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                var modifiedCellValuesChange = _step3.value;
+                (0, _error_utils.invariant)(modifiedCellValuesChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE, 'Modified cell value change is not a supported type in record');
+                var fieldIdsByRecordId = modifiedCellValuesChange.fieldIdsByRecordId;
+                var fieldIdsForThisRecord = fieldIdsByRecordId[this.id];
+
+                if (fieldIdsForThisRecord) {
+                  fieldIdsModified = fieldIdsModified.concat(fieldIdsForThisRecord);
+                }
+              }
+            } catch (err) {
+              _didIteratorError3 = true;
+              _iteratorError3 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                  _iterator3.return();
+                }
+              } finally {
+                if (_didIteratorError3) {
+                  throw _iteratorError3;
+                }
+              }
+            }
+
+            callbackForRegistration.call(context, this, key, fieldIdsModified);
+          };
+
+          break;
+
+        default:
+          // The else cases should be impossible to reach - they indicate a SDK error.
+          // istanbul ignore else
+          if (key.startsWith(WatchableCellValueInFieldKeyPrefix)) {
+            var fieldId = key.substring(WatchableCellValueInFieldKeyPrefix.length); // Assert that fieldId is validly formatted, not that it is a valid fieldId in this table
+
+            (0, _error_utils.invariant)((0, _private_utils.isFieldId)(fieldId), 'fieldId passed as watchable fieldId is not a valid format' + fieldId);
+            fieldSelectionDefinition = {
+              type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+              fieldIds: [fieldId]
+            };
+
+            onChangeCallback = changes => {
+              // We could check if something else changed in the changes array,
+              // but our query subscription is targeting only the field in this record
+              callbackForRegistration.call(context, this, key, fieldId);
+            };
+          } else if (key.startsWith(WatchableColorInViewKeyPrefix)) {
+            throw (0, _error_utils.spawnError)('WatchableColorInViewKeyPrefix must be handled outside of query system');
+          } else {
+            throw (0, _error_utils.spawnError)('invalid record (un)watch key %s', key);
+          }
 
-          this._onChange(WatchableCellValueInFieldKeyPrefix + fieldId, fieldId);
-        }
       }
 
-      if (commentCount) {
-        this._onChange(WatchableRecordKeys.commentCount);
+      return {
+        querySpecToSubscribeWith: this._constructBlockFieldSelectionSpec(fieldSelectionDefinition),
+        onChangeCallback
+      };
+    }
+    /** @inheritdoc */
+
+  }, {
+    key: "watch",
+    value: function watch(keys, callbackForRegistration, context) {
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'watch');
+
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = validKeys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var key = _step4.value;
+
+          if (_isKeySubscribeableViaRecordQuery(key)) {
+            var _this$_constructBlock = this._constructBlockQuerySpecAndCallbackForWatchableKey(key, callbackForRegistration, context),
+                querySpecToSubscribeWith = _this$_constructBlock.querySpecToSubscribeWith,
+                onChangeCallback = _this$_constructBlock.onChangeCallback;
+
+            this._queryManager.watchWithQuerySpec(querySpecToSubscribeWith, this, key, onChangeCallback, callbackForRegistration, context);
+          } else {
+            // fallback to regular watch logic
+            (0, _error_utils.invariant)(key.startsWith(WatchableColorInViewKeyPrefix), 'Unexpected key in watch: %s', key);
+            var viewId = key.substring(WatchableColorInViewKeyPrefix.length);
+
+            this._parentRecordStore.getViewDataStore(viewId).watch('recordColors', this._onRecordColorChange);
+
+            (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "watch", this).call(this, key, callbackForRegistration, context);
+          }
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
       }
+
+      return validKeys;
     }
-    /**
-     * @internal
-     */
+    /** @inheritdoc */
 
   }, {
-    key: "__triggerOnChangeForRecordColorInViewId",
-    value: function __triggerOnChangeForRecordColorInViewId(viewId) {
-      this._onChange(WatchableColorInViewKeyPrefix + viewId);
+    key: "unwatch",
+    value: function unwatch(keys, callbackForRegistration, context) {
+      // We warn instead of throw here because we used to warn instead of throw and don't
+      // want to make a breaking change.
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'unwatch', true);
+
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
+
+      try {
+        for (var _iterator5 = validKeys[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var key = _step5.value;
+
+          if (_isKeySubscribeableViaRecordQuery(key)) {
+            this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context);
+          } else {
+            // fallback to regular watch logic
+            (0, _error_utils.invariant)(key.startsWith(WatchableColorInViewKeyPrefix), 'Unexpected key in unwatch: %s', key);
+            var viewId = key.substring(WatchableColorInViewKeyPrefix.length);
+
+            this._parentRecordStore.getViewDataStore(viewId).unwatch('recordColors', this._onRecordColorChange);
+
+            (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "unwatch", this).call(this, key, callbackForRegistration, context);
+          }
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+
+      return validKeys;
     }
+    /** @internal */
+
   }, {
     key: "_dataOrNullIfDeleted",
     get: function get() {
-      var _recordsById$this$_id;
-
       var tableData = this._baseData.tablesById[this.parentTable.id];
 
       if (!tableData) {
         return null;
       }
 
-      var recordsById = tableData.recordsById;
-      (0, _error_utils.invariant)(recordsById, 'Record data is not loaded');
-      return (_recordsById$this$_id = recordsById[this._id]) !== null && _recordsById$this$_id !== void 0 ? _recordsById$this$_id : null;
-    }
-    /**
-     * The table that this record belongs to. Should never change because records aren't moved between tables.
-     *
-     * @internal (since we may not be able to return parent model instances in the immutable models world)
-     * @example
-     * ```js
-     * import {useRecords} from '@airtable/blocks/ui';
-     * const records = useRecords(myTable);
-     * console.log(records[0].parentTable.id === myTable.id);
-     * // => true
-     * ```
-     */
+      var isRecordLoaded = this._parentRecordStore.isRecordLoaded(this._id);
+
+      (0, _error_utils.invariant)(isRecordLoaded, 'Record data is not loaded');
+
+      var isRecordDeleted = this._parentRecordStore.isRecordDeleted(this._id);
 
+      return isRecordDeleted ? null : true;
+    }
   }, {
     key: "parentTable",
     get: function get() {
@@ -551,7 +800,9 @@ function (_AbstractModel) {
   }, {
     key: "commentCount",
     get: function get() {
-      return this._data.commentCount;
+      this._assertExistsAndLoaded();
+
+      return this._parentRecordStore.getRecordCommentCount(this._id);
     }
     /**
      * The created time of this record.
@@ -567,7 +818,9 @@ function (_AbstractModel) {
   }, {
     key: "createdTime",
     get: function get() {
-      return new Date(this._data.createdTime);
+      this._assertExistsAndLoaded();
+
+      return this._parentRecordStore.getRecordCreatedTime(this._id);
     }
   }]);
   return Record;
@@ -575,4 +828,5 @@ function (_AbstractModel) {
 
 (0, _defineProperty2.default)(Record, "_className", 'Record');
 var _default = Record;
-exports.default = _default;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/models/record.ts"],"names":["WatchableRecordKeys","Object","freeze","name","commentCount","cellValues","WatchableCellValueInFieldKeyPrefix","WatchableColorInViewKeyPrefix","_isKeySubscribeableViaRecordQuery","key","startsWith","Record","sdk","parentRecordStore","parentTable","recordId","viewDataStore","recordIds","includes","id","_onChange","viewId","_parentRecordStore","_parentTable","_queryManager","__linkedRecordsQueryResultPool","ObjectPool","LinkedRecordsQueryResult","data","_dataOrNullIfDeleted","_spawnErrorForDeletion","fieldOrFieldIdOrFieldName","__getFieldMatching","viewOrViewIdOrViewName","__getViewMatching","field","_assertExistsAndLoaded","isCellValueLoadedForField","isRecordCellValueLoadedForFieldId","_id","cellValue","getRecordCellValueByFieldId","_getFieldMatching","_getRawCellValue","type","FieldType","MULTIPLE_LOOKUP_VALUES","_sdk","__airtableInterface","sdkInitData","isUsingNewLookupCellValueFormat","cellValueForMigration","Array","isArray","linkedRecordIds","linkedRecordId","valuesByLinkedRecordId","value","v","push","undefined","airtableInterface","appInterface","__appInterface","fieldTypeProvider","convertCellValueToString","_data","attachmentId","attachmentUrl","urlConstructor","getAttachmentClientUrl","view","_getViewMatching","getViewDataStore","getRecordColor","color","getColorInView","colorUtils","getHexForColor","opts","linkedTableId","options","linkedTable","base","getTableById","linkedRecordStore","__getRecordStore","normalizedOpts","RecordQueryResult","_normalizeOpts","getObjectForReuse","queryResult","selectLinkedRecordsFromCell","loadDataAsync","fieldSelection","sourceType","BlockQuerySourceType","TABLE","sourceTableId","recordSelection","changes","changeTypeToMatch","filter","change","tableId","callbackForRegistration","context","fieldSelectionDefinition","onChangeCallback","call","BlockFieldSelectionSpecType","SPECIFIED_FIELDS","fieldIds","primaryField","shouldIncludeCommentCount","ALL_FIELDS_FROM_TABLE","modifiedCellValuesChanges","_findMatchingBlockSubscriptionChanges","BlockQuerySubscriptionChangeType","MODIFIED_CELL_VALUES_FOR_TABLE","length","fieldIdsModified","modifiedCellValuesChange","fieldIdsByRecordId","fieldIdsForThisRecord","concat","fieldId","substring","querySpecToSubscribeWith","_constructBlockFieldSelectionSpec","keys","validKeys","_getWatchableValidKeysOrThrow","_constructBlockQuerySpecAndCallbackForWatchableKey","watchWithQuerySpec","watch","_onRecordColorChange","unwatchFromQueryKey","unwatch","tableData","_baseData","tablesById","isRecordLoaded","isRecordDeleted","getRecordUrl","getCellValueAsString","getRecordCommentCount","getRecordCreatedTime","AbstractModel"],"mappings":"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","sourcesContent":["/** @module @airtable/blocks/models: Record */ /** */\nimport {Color} from '../colors';\nimport Sdk from '../sdk';\nimport {RecordId} from '../types/record';\nimport {FieldType, FieldId} from '../types/field';\nimport {ViewId} from '../types/view';\nimport {\n    isEnumValue,\n    cloneDeep,\n    ObjectValues,\n    FlowAnyObject,\n    FlowAnyFunction,\n    isFieldId,\n} from '../private_utils';\nimport {invariant, spawnError} from '../error_utils';\nimport colorUtils from '../color_utils';\nimport {\n    BlockFieldSelectionSpecType,\n    BlockQuerySpec,\n    BlockQuerySourceType,\n    BlockQuerySubscriptionChange,\n    BlockQuerySubscriptionChangeType,\n    BlockQuerySubscriptionOnChangeCallback,\n    BlockFieldSelectionSpec,\n} from '../types/block_query_spec';\nimport AbstractModel from './abstract_model';\nimport Field from './field';\nimport ObjectPool from './object_pool';\nimport Table from './table';\nimport View from './view';\nimport RecordQueryResult, {RecordQueryResultOpts} from './record_query_result';\nimport LinkedRecordsQueryResult from './linked_records_query_result';\nimport RecordStore from './record_store';\nimport {QueryManager} from './query_manager';\nimport ViewDataStore from './view_data_store';\n\nconst WatchableRecordKeys = Object.freeze({\n    name: 'name' as const,\n    commentCount: 'commentCount' as const,\n    // TODO(kasra): these keys don't have matching getters (not that they should\n    // it's just inconsistent...)\n    cellValues: 'cellValues' as const,\n});\n// TODO: load cell values in field when this is watched? This will\n// cause the CellRenderer component to load cell values, which seems okay,\n// but needs a little more thought.\nconst WatchableCellValueInFieldKeyPrefix = 'cellValueInField:';\n// TODO: load view data when this is watched. see previous comment.\nconst WatchableColorInViewKeyPrefix = 'colorInView:';\n/**\n * Any key within record that can be watched:\n * - `'name'`\n * - `'commentCount'`\n * - `'cellValues'`\n * - `'cellValueInField:' + someFieldId`\n * - `'colorInView:' + someViewId`\n */\ntype WatchableRecordKey = ObjectValues<typeof WatchableRecordKeys> | string;\n\n/**\n * TODO: (#proj-blocks-sdk-record-limits) Record should probably not be an AbstractModel,\n * in the meantime it will return true if it's loaded, throwing/returning null\n * if it's not loaded (returning null / throwing is how AbstractModel works).\n */\ntype RecordStoreIsLoaded = true;\n\nfunction _isKeySubscribeableViaRecordQuery(key: WatchableRecordKey): boolean {\n    switch (key) {\n        case WatchableRecordKeys.name:\n        case WatchableRecordKeys.commentCount:\n        case WatchableRecordKeys.cellValues:\n            return true;\n        default:\n            if (key.startsWith(WatchableCellValueInFieldKeyPrefix)) {\n                return true;\n            }\n            break;\n    }\n    return false;\n}\n\n/**\n * Model class representing a record in a table.\n *\n * Do not instantiate. You can get instances of this class by calling `table.selectRecords`\n * or `view.selectRecords` and using the resulting {@link RecordQueryResult}.\n *\n * @docsPath models/Record\n */\nclass Record extends AbstractModel<RecordStoreIsLoaded, WatchableRecordKey> {\n    /** @internal */\n    static _className = 'Record';\n    /** @internal */\n    static _isWatchableKey(key: string): boolean {\n        return (\n            isEnumValue(WatchableRecordKeys, key) ||\n            key.startsWith(WatchableCellValueInFieldKeyPrefix) ||\n            key.startsWith(WatchableColorInViewKeyPrefix)\n        );\n    }\n    /** @internal */\n    _parentRecordStore: RecordStore;\n    /** @internal */\n    _parentTable: Table;\n    /** @internal */\n    readonly _queryManager: QueryManager;\n    /** @internal */\n    __linkedRecordsQueryResultPool: ObjectPool<\n        LinkedRecordsQueryResult,\n        typeof LinkedRecordsQueryResult\n    >;\n\n    /**\n     * @internal\n     */\n    constructor(sdk: Sdk, parentRecordStore: RecordStore, parentTable: Table, recordId: string) {\n        super(sdk, recordId);\n\n        this._parentRecordStore = parentRecordStore;\n        this._parentTable = parentTable;\n        this._queryManager = sdk._queryManager;\n        this.__linkedRecordsQueryResultPool = new ObjectPool(LinkedRecordsQueryResult);\n    }\n\n    /**\n     * @internal\n     */\n    get _dataOrNullIfDeleted(): RecordStoreIsLoaded | null {\n        const tableData = this._baseData.tablesById[this.parentTable.id];\n        if (!tableData) {\n            return null;\n        }\n        const isRecordLoaded = this._parentRecordStore.isRecordLoaded(this._id);\n        invariant(isRecordLoaded, 'Record data is not loaded');\n        const isRecordDeleted = this._parentRecordStore.isRecordDeleted(this._id);\n        return isRecordDeleted ? null : true;\n    }\n\n    /**\n     * @internal\n     */\n    _assertExistsAndLoaded(): void {\n        // Access data in order to throw if the Record has been deleted / isn't loaded\n        const data = this._dataOrNullIfDeleted;\n        if (data === null) {\n            throw this._spawnErrorForDeletion();\n        }\n    }\n\n    /**\n     * The table that this record belongs to. Should never change because records aren't moved between tables.\n     *\n     * @internal (since we may not be able to return parent model instances in the immutable models world)\n     * @example\n     * ```js\n     * import {useRecords} from '@airtable/blocks/ui';\n     * const records = useRecords(myTable);\n     * console.log(records[0].parentTable.id === myTable.id);\n     * // => true\n     * ```\n     */\n    get parentTable(): Table {\n        return this._parentTable;\n    }\n    /**\n     * @internal\n     */\n    _getFieldMatching(fieldOrFieldIdOrFieldName: Field | string): Field {\n        return this.parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName);\n    }\n    /**\n     * @internal\n     */\n    _getViewMatching(viewOrViewIdOrViewName: View | string): View {\n        return this.parentTable.__getViewMatching(viewOrViewIdOrViewName);\n    }\n\n    /**\n     * @internal\n     *\n     * For use when we need the raw public API cell value. Specifically makes a difference\n     * for lookup fields, where we translate the format to a blocks-specific format in getCellValue.\n     * That format is incompatible with fieldTypeProvider methods, which expect the public API\n     * format - use _getRawCellValue instead.\n     */\n    _getRawCellValue(field: Field): unknown {\n        this._assertExistsAndLoaded();\n\n        // TODO: (#proj-blocks-sdk-record-limits) Consider a new API that allows determining\n        // if the cell value is loaded + getting the cellValue in one call?\n        const isCellValueLoadedForField = this._parentRecordStore.isRecordCellValueLoadedForFieldId(\n            this._id,\n            field.id,\n        );\n        invariant(\n            isCellValueLoadedForField,\n            'Cell value for field %s and record %s is not loaded',\n            field.id,\n            this._id,\n        );\n\n        const cellValue = this._parentRecordStore.getRecordCellValueByFieldId(this._id, field.id);\n\n        if (typeof cellValue === 'object' && cellValue !== null) {\n            // Copy non-primitives.\n            // TODO: (#proj-blocks-sdk-record-limits): getRecordCellValueByFieldId returns\n            // deeply frozen objects, in a later sdk version we can drop cloning deeply.\n            return cloneDeep(cellValue);\n        } else {\n            return cellValue;\n        }\n    }\n    /**\n     * Gets the cell value of the given field for this record.\n     *\n     * @param fieldOrFieldIdOrFieldName The field (or field ID or field name) whose cell value you'd like to get.\n     * @example\n     * ```js\n     * const cellValue = myRecord.getCellValue(mySingleLineTextField);\n     * console.log(cellValue);\n     * // => 'cell value'\n     * ```\n     */\n    getCellValue(fieldOrFieldIdOrFieldName: Field | FieldId | string): unknown {\n        const field = this._getFieldMatching(fieldOrFieldIdOrFieldName);\n        const cellValue = this._getRawCellValue(field);\n\n        // HACK: migrate to new public lookup cell value format if needed\n        if (\n            typeof cellValue === 'object' &&\n            cellValue !== null &&\n            field.type === FieldType.MULTIPLE_LOOKUP_VALUES &&\n            !this._sdk.__airtableInterface.sdkInitData.isUsingNewLookupCellValueFormat\n        ) {\n            const cellValueForMigration: Array<{linkedRecordId: RecordId; value: unknown}> = [];\n            invariant(Array.isArray((cellValue as any).linkedRecordIds), 'linkedRecordIds');\n            for (const linkedRecordId of (cellValue as any).linkedRecordIds) {\n                invariant(typeof linkedRecordId === 'string', 'linkedRecordId');\n                const {valuesByLinkedRecordId} = cellValue as any;\n\n                invariant(\n                    valuesByLinkedRecordId && typeof valuesByLinkedRecordId === 'object',\n                    'valuesByLinkedRecordId',\n                );\n\n                const value = valuesByLinkedRecordId[linkedRecordId];\n                if (Array.isArray(value)) {\n                    for (const v of value) {\n                        cellValueForMigration.push({linkedRecordId, value: v});\n                    }\n                } else {\n                    cellValueForMigration.push({linkedRecordId, value});\n                }\n            }\n            return cellValueForMigration;\n        }\n\n        return cellValue;\n    }\n    /**\n     * Gets the cell value of the given field for this record, formatted as a `string`.\n     *\n     * @param fieldOrFieldIdOrFieldName The field (or field ID or field name) whose cell value you'd like to get.\n     * @example\n     * ```js\n     * const stringValue = myRecord.getCellValueAsString(myNumberField);\n     * console.log(stringValue);\n     * // => '42'\n     * ```\n     */\n    getCellValueAsString(fieldOrFieldIdOrFieldName: Field | FieldId | string): string {\n        const field = this._getFieldMatching(fieldOrFieldIdOrFieldName);\n\n        // getRawCellValue performs invariant check that cell value at the field is loaded\n        const cellValue = this._getRawCellValue(field);\n\n        if (cellValue === null || cellValue === undefined) {\n            return '';\n        } else {\n            const airtableInterface = this._sdk.__airtableInterface;\n            const appInterface = this._sdk.__appInterface;\n            return airtableInterface.fieldTypeProvider.convertCellValueToString(\n                appInterface,\n                cellValue,\n                field._data,\n            );\n        }\n    }\n    /**\n     * Returns a URL that is suitable for rendering an attachment on the current client.\n     * The URL that is returned will only work for the current user.\n     *\n     * @param attachmentId The ID of the attachment.\n     * @param attachmentUrl The attachment's URL (which is not suitable for rendering on the client).\n     * @example\n     * ```js\n     * import React from 'react';\n     *\n     * function RecordAttachments(props) {\n     *     const {record, attachmentField} = props;\n     *     const attachmentCellValue = record.getCellValue(attachmentField);\n     *     if (attachmentCellValue === null) {\n     *         return null;\n     *     }\n     *     return (\n     *         <div>\n     *             {attachmentCellValue.map(attachmentObj => {\n     *                 const clientUrl =\n     *                     record.getAttachmentClientUrlFromCellValueUrl(\n     *                         attachmentObj.id,\n     *                         attachmentObj.url\n     *                     );\n     *                 return (\n     *                     <img key={attachmentObj.id} src={clientUrl} width={200} />\n     *                 );\n     *             })}\n     *         </div>\n     *     );\n     * }\n     * ```\n     */\n    getAttachmentClientUrlFromCellValueUrl(attachmentId: string, attachmentUrl: string): string {\n        const airtableInterface = this._sdk.__airtableInterface;\n        const appInterface = this._sdk.__appInterface;\n        return airtableInterface.urlConstructor.getAttachmentClientUrl(\n            appInterface,\n            attachmentId,\n            attachmentUrl,\n        );\n    }\n    /**\n     * Gets the color of this record in a given view, or null if the record has no color in that\n     * view.\n     *\n     * Can be watched with the 'colorInView:${ViewId}' key.\n     *\n     * @param viewOrViewIdOrViewName The view (or view ID or view name) to use for record coloring.\n     */\n    getColorInView(viewOrViewIdOrViewName: View | ViewId | string): Color | null {\n        const view = this._getViewMatching(viewOrViewIdOrViewName);\n\n        return this._parentRecordStore.getViewDataStore(view.id).getRecordColor(this);\n    }\n    /**\n     * Gets the CSS hex string for this record in a given view, or null if the record has no color\n     * in that view.\n     *\n     * Can be watched with the 'colorInView:${ViewId}' key.\n     *\n     * @param viewOrViewIdOrViewName The view (or view ID or view name) to use for record coloring.\n     */\n    getColorHexInView(viewOrViewIdOrViewName: View | string): string | null {\n        const color = this.getColorInView(viewOrViewIdOrViewName);\n        if (!color) {\n            return null;\n        }\n        return colorUtils.getHexForColor(color);\n    }\n    /**\n     * Select records referenced in a `multipleRecordLinks` cell value. Returns a query result\n     * containing the records in the given `multipleRecordLinks` field.\n     * See {@link RecordQueryResult} for more.\n     *\n     * @param fieldOrFieldIdOrFieldName The `multipleRecordLinks` field (or field ID or field name) to use.\n     * @param opts Options for the query, such as sorts and fields.\n     */\n    selectLinkedRecordsFromCell(\n        fieldOrFieldIdOrFieldName: Field | FieldId | string,\n        opts: RecordQueryResultOpts = {},\n    ): LinkedRecordsQueryResult {\n        const field = this._getFieldMatching(fieldOrFieldIdOrFieldName);\n        const linkedTableId = field.options && field.options.linkedTableId;\n        invariant(typeof linkedTableId === 'string', 'linkedTableId must be set');\n\n        const linkedTable = this._sdk.base.getTableById(linkedTableId);\n        const linkedRecordStore = this._sdk.base.__getRecordStore(linkedTableId);\n\n        const normalizedOpts = RecordQueryResult._normalizeOpts(\n            linkedTable,\n            linkedRecordStore,\n            opts,\n        );\n        return this.__linkedRecordsQueryResultPool.getObjectForReuse(\n            this,\n            field,\n            normalizedOpts,\n            this._sdk,\n        );\n    }\n    /**\n     * Select and load records referenced in a `multipleRecordLinks` cell value. Returns a query result\n     * promise containing the records in the given `multipleRecordLinks` field.\n     * See {@link RecordQueryResult} for more.\n     *\n     * Remember to call `queryResult.unloadData` once you're finished with the query.\n     *\n     * @param fieldOrFieldIdOrFieldName The `multipleRecordLinks` field (or field ID or field name) to use.\n     * @param opts Options for the query, such as sorts and fields.\n     */\n    async selectLinkedRecordsFromCellAsync(\n        fieldOrFieldIdOrFieldName: Field | FieldId | string,\n        opts: RecordQueryResultOpts = {},\n    ): Promise<LinkedRecordsQueryResult> {\n        const queryResult = this.selectLinkedRecordsFromCell(fieldOrFieldIdOrFieldName, opts);\n        await queryResult.loadDataAsync();\n        return queryResult;\n    }\n    /**\n     * The URL for the record. You can visit this URL in the browser to be taken to the record in the Airtable UI.\n     *\n     * @example\n     * ```js\n     * console.log(myRecord.url);\n     * // => 'https://airtable.com/tblxxxxxxxxxxxxxx/recxxxxxxxxxxxxxx'\n     * ```\n     */\n    get url(): string {\n        return this._sdk.__airtableInterface.urlConstructor.getRecordUrl(\n            this.id,\n            this.parentTable.id,\n        );\n    }\n    /**\n     * The primary cell value in this record, formatted as a `string`.\n     *\n     * @example\n     * ```js\n     * console.log(myRecord.name);\n     * // => '42'\n     * ```\n     */\n    get name(): string {\n        return this.getCellValueAsString(this.parentTable.primaryField);\n    }\n    /**\n     * The number of comments on this record.\n     *\n     * @example\n     * ```js\n     * const commentCount = myRecord.commentCount;\n     * const isSingular = commentCount === 1;\n     * console.log(\n     *     `This record has ${commentCount} comment${isSingular ? '' : 's'}`\n     * );\n     * ```\n     */\n    get commentCount(): number {\n        this._assertExistsAndLoaded();\n\n        return this._parentRecordStore.getRecordCommentCount(this._id);\n    }\n    /**\n     * The created time of this record.\n     *\n     * @example\n     * ```js\n     * console.log(`\n     *     This record was created at ${myRecord.createdTime.toISOString()}\n     * `);\n     * ```\n     */\n    get createdTime(): Date {\n        this._assertExistsAndLoaded();\n\n        return this._parentRecordStore.getRecordCreatedTime(this._id);\n    }\n\n    /**\n     * @internal\n     */\n    _constructBlockFieldSelectionSpec(fieldSelection: BlockFieldSelectionSpec): BlockQuerySpec {\n        return {\n            sourceType: BlockQuerySourceType.TABLE,\n            sourceTableId: this.parentTable.id,\n            recordSelection: {\n                recordIds: [this.id],\n                fieldSelection,\n            },\n        };\n    }\n\n    /**\n     * @internal\n     */\n    _findMatchingBlockSubscriptionChanges(\n        changes: Array<BlockQuerySubscriptionChange>,\n        changeTypeToMatch: BlockQuerySubscriptionChangeType,\n    ): Array<BlockQuerySubscriptionChange> {\n        return changes.filter(\n            change => change.type === changeTypeToMatch && change.tableId === this.parentTable.id,\n        );\n    }\n\n    /**\n     * @internal\n     */\n    _constructBlockQuerySpecAndCallbackForWatchableKey(\n        key: WatchableRecordKey,\n        callbackForRegistration: Function,\n        context?: unknown | null,\n    ): {\n        querySpecToSubscribeWith: BlockQuerySpec;\n        onChangeCallback: BlockQuerySubscriptionOnChangeCallback;\n    } {\n        let fieldSelectionDefinition: BlockFieldSelectionSpec;\n        let onChangeCallback: BlockQuerySubscriptionOnChangeCallback = () => {\n            callbackForRegistration.call(context, this, key);\n        };\n\n        switch (key) {\n            case WatchableRecordKeys.name:\n                fieldSelectionDefinition = {\n                    type: BlockFieldSelectionSpecType.SPECIFIED_FIELDS,\n                    fieldIds: [this.parentTable.primaryField.id],\n                };\n                break;\n            case WatchableRecordKeys.commentCount:\n                fieldSelectionDefinition = {\n                    type: BlockFieldSelectionSpecType.SPECIFIED_FIELDS,\n                    fieldIds: [],\n                    shouldIncludeCommentCount: true,\n                };\n                break;\n            case WatchableRecordKeys.cellValues:\n                // TODO: (#proj-blocks-sdk-record-limits) In the future don't fetch all fields from table\n                // old code exhibit this behavior though: https://github.com/Hyperbase/blocks-sdk/blob/aba6fa7b7f8ccc1e364b409ca466d0281f8e9a69/packages/sdk/src/models/record.ts#L414-L416\n                // In the future a \"subscribe to updates, but don't fetch more data\" might be useful here.\n                fieldSelectionDefinition = {\n                    type: BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE,\n                };\n\n                onChangeCallback = (changes: Array<BlockQuerySubscriptionChange>) => {\n                    const modifiedCellValuesChanges = this._findMatchingBlockSubscriptionChanges(\n                        changes,\n                        BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE,\n                    );\n\n                    // We do not currently simulate \"on load\" callback for registration\n                    // but still handle it.\n                    if (modifiedCellValuesChanges.length === 0) {\n                        callbackForRegistration.call(context, this, key);\n                        return;\n                    }\n\n                    let fieldIdsModified: Array<FieldId> = [];\n\n                    for (const modifiedCellValuesChange of modifiedCellValuesChanges) {\n                        invariant(\n                            modifiedCellValuesChange.type ===\n                                BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE,\n                            'Modified cell value change is not a supported type in record',\n                        );\n                        const {fieldIdsByRecordId} = modifiedCellValuesChange;\n                        const fieldIdsForThisRecord = fieldIdsByRecordId[this.id];\n                        if (fieldIdsForThisRecord) {\n                            fieldIdsModified = fieldIdsModified.concat(fieldIdsForThisRecord);\n                        }\n                    }\n\n                    callbackForRegistration.call(context, this, key, fieldIdsModified);\n                };\n                break;\n\n            default:\n                // The else cases should be impossible to reach - they indicate a SDK error.\n                // istanbul ignore else\n                if (key.startsWith(WatchableCellValueInFieldKeyPrefix)) {\n                    const fieldId = key.substring(WatchableCellValueInFieldKeyPrefix.length);\n\n                    // Assert that fieldId is validly formatted, not that it is a valid fieldId in this table\n                    invariant(\n                        isFieldId(fieldId),\n                        'fieldId passed as watchable fieldId is not a valid format' + fieldId,\n                    );\n\n                    fieldSelectionDefinition = {\n                        type: BlockFieldSelectionSpecType.SPECIFIED_FIELDS,\n                        fieldIds: [fieldId],\n                    };\n\n                    onChangeCallback = (changes: Array<BlockQuerySubscriptionChange>) => {\n                        // We could check if something else changed in the changes array,\n                        // but our query subscription is targeting only the field in this record\n                        callbackForRegistration.call(context, this, key, fieldId);\n                    };\n                } else if (key.startsWith(WatchableColorInViewKeyPrefix)) {\n                    throw spawnError(\n                        'WatchableColorInViewKeyPrefix must be handled outside of query system',\n                    );\n                } else {\n                    throw spawnError('invalid record (un)watch key %s', key);\n                }\n        }\n\n        return {\n            querySpecToSubscribeWith: this._constructBlockFieldSelectionSpec(\n                fieldSelectionDefinition,\n            ),\n            onChangeCallback,\n        };\n    }\n\n    /** @inheritdoc */\n    watch(\n        keys: WatchableRecordKey | ReadonlyArray<WatchableRecordKey>,\n        callbackForRegistration: FlowAnyFunction,\n        context?: FlowAnyObject | null,\n    ): Array<WatchableRecordKey> {\n        const validKeys = this._getWatchableValidKeysOrThrow(keys, 'watch');\n\n        for (const key of validKeys) {\n            if (_isKeySubscribeableViaRecordQuery(key)) {\n                const {\n                    querySpecToSubscribeWith,\n                    onChangeCallback,\n                } = this._constructBlockQuerySpecAndCallbackForWatchableKey(\n                    key,\n                    callbackForRegistration,\n                    context,\n                );\n                this._queryManager.watchWithQuerySpec(\n                    querySpecToSubscribeWith,\n                    this,\n                    key,\n                    onChangeCallback,\n                    callbackForRegistration,\n                    context,\n                );\n            } else {\n                // fallback to regular watch logic\n\n                invariant(\n                    key.startsWith(WatchableColorInViewKeyPrefix),\n                    'Unexpected key in watch: %s',\n                    key,\n                );\n                const viewId = key.substring(WatchableColorInViewKeyPrefix.length);\n\n                this._parentRecordStore\n                    .getViewDataStore(viewId)\n                    .watch('recordColors', this._onRecordColorChange);\n\n                super.watch(key, callbackForRegistration, context);\n            }\n        }\n\n        return validKeys;\n    }\n\n    /** @inheritdoc */\n    unwatch(\n        keys: WatchableRecordKey | ReadonlyArray<WatchableRecordKey>,\n        callbackForRegistration: FlowAnyFunction,\n        context?: FlowAnyObject | null,\n    ): Array<WatchableRecordKey> {\n        // We warn instead of throw here because we used to warn instead of throw and don't\n        // want to make a breaking change.\n        const validKeys = this._getWatchableValidKeysOrThrow(keys, 'unwatch', true);\n\n        for (const key of validKeys) {\n            if (_isKeySubscribeableViaRecordQuery(key)) {\n                this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context);\n            } else {\n                // fallback to regular watch logic\n                invariant(\n                    key.startsWith(WatchableColorInViewKeyPrefix),\n                    'Unexpected key in unwatch: %s',\n                    key,\n                );\n                const viewId = key.substring(WatchableColorInViewKeyPrefix.length);\n\n                this._parentRecordStore\n                    .getViewDataStore(viewId)\n                    .unwatch('recordColors', this._onRecordColorChange);\n\n                super.unwatch(key, callbackForRegistration, context);\n            }\n        }\n\n        return validKeys;\n    }\n\n    /** @internal */\n    _onRecordColorChange = (\n        viewDataStore: ViewDataStore,\n        key: string,\n        recordIds: Array<RecordId>,\n    ) => {\n        if (recordIds.includes(this.id)) {\n            this._onChange(WatchableColorInViewKeyPrefix + viewDataStore.viewId);\n        }\n    };\n}\n\nexport default Record;\n"]}

package/dist/cjs/models/record_coloring.js

@@ -114,4 +114,5 @@ var modes = {
   }
 
 };
-exports.modes = modes;
+exports.modes = modes;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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