@airtable/blocks 0.0.0-experimental-20e3506bd-20250428

package/dist/cjs/shared/models/record_core.js

@@ -0,0 +1,272 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatchableRecordKeysCore = exports.RecordCore = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _private_utils = require("../private_utils");
+var _error_utils = require("../error_utils");
+var _field = require("../types/field");
+var _abstract_model = _interopRequireDefault(require("./abstract_model"));
+var _field_core = require("./field_core");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var WatchableRecordKeysCore = exports.WatchableRecordKeysCore = Object.freeze({
+  name: 'name',
+  // TODO(kasra): these keys don't have matching getters (not that they should
+  // it's just inconsistent...)
+  cellValues: 'cellValues'
+});
+
+/** @hidden */
+/** @hidden */
+var RecordCore = exports.RecordCore = /*#__PURE__*/function (_AbstractModel) {
+  /**
+   * @internal
+   */
+  function RecordCore(sdk, parentRecordStore, parentTable, recordId) {
+    var _this;
+    (0, _classCallCheck2.default)(this, RecordCore);
+    _this = _callSuper(this, RecordCore, [sdk, recordId]);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_parentRecordStore", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_parentTable", void 0);
+    _this._parentRecordStore = parentRecordStore;
+    _this._parentTable = parentTable;
+    return _this;
+  }
+
+  /**
+   * @internal
+   */
+  (0, _inherits2.default)(RecordCore, _AbstractModel);
+  return (0, _createClass2.default)(RecordCore, [{
+    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
+     * ```
+     */
+  }, {
+    key: "parentTable",
+    get: function get() {
+      return this._parentTable;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "_getFieldMatching",
+    value: function _getFieldMatching(fieldOrFieldIdOrFieldName) {
+      if (fieldOrFieldIdOrFieldName instanceof _field_core.FieldCore) {
+        return this._parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName.id);
+      }
+      return this.parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName);
+    }
+
+    /**
+     * @internal
+     *
+     * For use when we need the raw public API cell value. Specifically makes a difference
+     * for lookup fields, where we translate the format to a blocks-specific format in getCellValue.
+     * That format is incompatible with fieldTypeProvider methods, which expect the public API
+     * format - use _getRawCellValue instead.
+     */
+  }, {
+    key: "_getRawCellValue",
+    value: function _getRawCellValue(field) {
+      var cellValuesByFieldId = this._data.cellValuesByFieldId;
+      if (!cellValuesByFieldId) {
+        return null;
+      }
+      var cellValue = cellValuesByFieldId[field.id] !== undefined ? cellValuesByFieldId[field.id] : null;
+      if (typeof cellValue === 'object' && cellValue !== null) {
+        // Copy non-primitives.
+        // TODO(kasra): maybe freezeDeep instead?
+        return (0, _private_utils.cloneDeep)(cellValue);
+      } else {
+        return cellValue;
+      }
+    }
+    /**
+     * Gets the cell value of the given field for this record.
+     *
+     * @param fieldOrFieldIdOrFieldName The field (or field ID or field name) whose cell value you'd like to get.
+     * @example
+     * ```js
+     * const cellValue = myRecord.getCellValue(mySingleLineTextField);
+     * console.log(cellValue);
+     * // => 'cell value'
+     * ```
+     */
+  }, {
+    key: "getCellValue",
+    value: function getCellValue(fieldOrFieldIdOrFieldName) {
+      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName);
+      var cellValue = this._getRawCellValue(field);
+
+      // HACK: migrate to new public lookup cell value format if needed
+      if (typeof cellValue === 'object' && cellValue !== null && field.type === _field.FieldType.MULTIPLE_LOOKUP_VALUES && !this._sdk.__airtableInterface.sdkInitData.isUsingNewLookupCellValueFormat) {
+        var cellValueForMigration = [];
+        (0, _error_utils.invariant)(Array.isArray(cellValue.linkedRecordIds), 'linkedRecordIds');
+        var _iterator = _createForOfIteratorHelper(cellValue.linkedRecordIds),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var linkedRecordId = _step.value;
+            (0, _error_utils.invariant)(typeof linkedRecordId === 'string', 'linkedRecordId');
+            var _ref = cellValue,
+              valuesByLinkedRecordId = _ref.valuesByLinkedRecordId;
+            (0, _error_utils.invariant)(valuesByLinkedRecordId && typeof valuesByLinkedRecordId === 'object', 'valuesByLinkedRecordId');
+            var value = valuesByLinkedRecordId[linkedRecordId];
+            if (Array.isArray(value)) {
+              var _iterator2 = _createForOfIteratorHelper(value),
+                _step2;
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var v = _step2.value;
+                  cellValueForMigration.push({
+                    linkedRecordId,
+                    value: v
+                  });
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+            } else {
+              cellValueForMigration.push({
+                linkedRecordId,
+                value
+              });
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        return cellValueForMigration;
+      }
+      return cellValue;
+    }
+    /**
+     * Gets the cell value of the given field for this record, formatted as a `string`.
+     *
+     * @param fieldOrFieldIdOrFieldName The field (or field ID or field name) whose cell value you'd like to get.
+     * @example
+     * ```js
+     * const stringValue = myRecord.getCellValueAsString(myNumberField);
+     * console.log(stringValue);
+     * // => '42'
+     * ```
+     */
+  }, {
+    key: "getCellValueAsString",
+    value: function getCellValueAsString(fieldOrFieldIdOrFieldName) {
+      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName);
+      var cellValue = this._getRawCellValue(field);
+      if (cellValue === null || cellValue === undefined) {
+        return '';
+      } else {
+        var airtableInterface = this._sdk.__airtableInterface;
+        var appInterface = this._sdk.__appInterface;
+        return airtableInterface.fieldTypeProvider.convertCellValueToString(appInterface, cellValue, field._data);
+      }
+    }
+    /**
+     * The primary cell value in this record, formatted as a `string`.
+     *
+     * @example
+     * ```js
+     * console.log(myRecord.name);
+     * // => '42'
+     * ```
+     */
+  }, {
+    key: "name",
+    get: function get() {
+      return this.getCellValueAsString(this.parentTable.primaryField);
+    }
+    /**
+     * The created time of this record.
+     *
+     * @example
+     * ```js
+     * console.log(`
+     *     This record was created at ${myRecord.createdTime.toISOString()}
+     * `);
+     * ```
+     */
+  }, {
+    key: "createdTime",
+    get: function get() {
+      return new Date(this._data.createdTime);
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__triggerOnChangeForDirtyPaths",
+    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      var cellValuesByFieldId = dirtyPaths.cellValuesByFieldId;
+      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(WatchableRecordKeysCore.cellValues, Object.keys(cellValuesByFieldId));
+        if (cellValuesByFieldId[this.parentTable.primaryField.id]) {
+          this._onChange(WatchableRecordKeysCore.name);
+        }
+      }
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableRecordKeysCore, key);
+    }
+  }]);
+}(_abstract_model.default);
+/** @internal */
+(0, _defineProperty2.default)(RecordCore, "_className", 'RecordCore');

package/dist/cjs/shared/models/record_store_core.js

@@ -0,0 +1,213 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WatchableRecordStoreKeysCore = exports.WatchableCellValuesInFieldKeyPrefix = void 0;
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.string.starts-with.js");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+var _abstract_model = _interopRequireDefault(require("../../shared/models/abstract_model"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var WatchableRecordStoreKeysCore = exports.WatchableRecordStoreKeysCore = Object.freeze({
+  records: 'records',
+  recordIds: 'recordIds',
+  cellValues: 'cellValues'
+});
+var WatchableCellValuesInFieldKeyPrefix = exports.WatchableCellValuesInFieldKeyPrefix = 'cellValuesInField:';
+
+/**
+ * The string case is to accommodate prefix keys
+ *
+ * @internal
+ */
+/**
+ * One RecordStore exists per table, and contains all the record data associated with that table.
+ * Table itself is for schema information only, so isn't the appropriate place for this data.
+ *
+ * @internal
+ */
+var RecordStoreCore = /*#__PURE__*/function (_AbstractModel) {
+  function RecordStoreCore(sdk, tableId) {
+    var _this;
+    (0, _classCallCheck2.default)(this, RecordStoreCore);
+    _this = _callSuper(this, RecordStoreCore, [sdk, "".concat(tableId, "-RecordStore")]);
+    (0, _defineProperty2.default)(_this, "tableId", void 0);
+    (0, _defineProperty2.default)(_this, "_recordModelsById", {});
+    _this.tableId = tableId;
+    return _this;
+  }
+  (0, _inherits2.default)(RecordStoreCore, _AbstractModel);
+  return (0, _createClass2.default)(RecordStoreCore, [{
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      var _this$_baseData$table;
+      return (_this$_baseData$table = this._baseData.tablesById[this.tableId]) !== null && _this$_baseData$table !== void 0 ? _this$_baseData$table : null;
+    }
+  }, {
+    key: "watch",
+    value: function watch(keys, callback, context) {
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStoreCore.prototype), "watch", this).call(this, keys, callback, context);
+      return validKeys;
+    }
+  }, {
+    key: "unwatch",
+    value: function unwatch(keys, callback, context) {
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStoreCore.prototype), "unwatch", this).call(this, keys, callback, context);
+      return validKeys;
+    }
+
+    /**
+     * The records in this table.
+     */
+  }, {
+    key: "records",
+    get: function get() {
+      var recordsById = this._data.recordsById;
+      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+      var records = this.recordIds.map(recordId => {
+        var record = this.getRecordByIdIfExists(recordId);
+        (0, _error_utils.invariant)(record, 'record');
+        return record;
+      });
+      return records;
+    }
+
+    /**
+     * The record IDs in this table.
+     */
+  }, {
+    key: "getRecordByIdIfExists",
+    value: function getRecordByIdIfExists(recordId) {
+      var 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');
+      if (!recordsById[recordId]) {
+        return null;
+      } else {
+        if (this._recordModelsById[recordId]) {
+          return this._recordModelsById[recordId];
+        }
+        var newRecord = this._constructRecord(recordId, this._sdk.base.getTableById(this.tableId));
+        this._recordModelsById[recordId] = newRecord;
+        return newRecord;
+      }
+    }
+  }, {
+    key: "triggerOnChangeForDirtyPaths",
+    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {
+      if (dirtyPaths.recordsById) {
+        // Since tables don't have a record order, need to detect if a record
+        // was created or deleted and trigger onChange for records.
+        var dirtyFieldIdsSet = {};
+        var addedRecordIds = [];
+        var removedRecordIds = [];
+        for (var _i = 0, _arr = (0, _private_utils.entries)(dirtyPaths.recordsById); _i < _arr.length; _i++) {
+          var _arr$_i = (0, _slicedToArray2.default)(_arr[_i], 2),
+            _recordId = _arr$_i[0],
+            dirtyRecordPaths = _arr$_i[1];
+          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)) {
+              addedRecordIds.push(_recordId);
+            } else {
+              removedRecordIds.push(_recordId);
+              var recordModel = this._recordModelsById[_recordId];
+              if (recordModel) {
+                // Remove the Record model if it was deleted.
+                delete this._recordModelsById[_recordId];
+              }
+            }
+          } else {
+            var _recordModel = this._recordModelsById[_recordId];
+            if (_recordModel) {
+              _recordModel.__triggerOnChangeForDirtyPaths(dirtyRecordPaths);
+            }
+          }
+          var cellValuesByFieldId = dirtyRecordPaths.cellValuesByFieldId;
+          if (cellValuesByFieldId) {
+            for (var _i2 = 0, _Object$keys = Object.keys(cellValuesByFieldId); _i2 < _Object$keys.length; _i2++) {
+              var fieldId = _Object$keys[_i2];
+              dirtyFieldIdsSet[fieldId] = true;
+            }
+          }
+        }
+
+        // Now that we've composed our created/deleted record ids arrays, let's fire
+        // the records onChange event if any records were created or deleted.
+        if (addedRecordIds.length > 0 || removedRecordIds.length > 0) {
+          this._onChange(WatchableRecordStoreKeysCore.records, {
+            addedRecordIds,
+            removedRecordIds
+          });
+          this._onChange(WatchableRecordStoreKeysCore.recordIds, {
+            addedRecordIds,
+            removedRecordIds
+          });
+        }
+
+        // NOTE: this is an experimental (and somewhat messy) way to watch
+        // for changes to cells in a table, as an alternative to implementing
+        // full event bubbling. For now, it unblocks the things we want to
+        // build, but we may replace it.
+        // If we keep it, could be more efficient by not calling _onChange
+        // if there are no subscribers.
+        // 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).
+        var fieldIds = Object.freeze(Object.keys(dirtyFieldIdsSet));
+        var _recordIds = Object.freeze(Object.keys(dirtyPaths.recordsById));
+        if (fieldIds.length > 0 && _recordIds.length > 0) {
+          this._onChange(WatchableRecordStoreKeysCore.cellValues, {
+            recordIds: _recordIds,
+            fieldIds
+          });
+        }
+        var _iterator = _createForOfIteratorHelper(fieldIds),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _fieldId = _step.value;
+            this._onChange(WatchableCellValuesInFieldKeyPrefix + _fieldId, _recordIds, _fieldId);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableRecordStoreKeysCore, key) || key.startsWith(WatchableCellValuesInFieldKeyPrefix);
+    }
+  }]);
+}(_abstract_model.default);
+/** @internal */
+(0, _defineProperty2.default)(RecordStoreCore, "_className", 'RecordStoreCore');
+var _default = exports.default = RecordStoreCore;