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

package/dist/cjs/base/models/object_pool.js

@@ -0,0 +1,184 @@
+"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.slice.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.find-index.js");
+require("core-js/modules/es.array.index-of.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _error_utils = require("../../shared/error_utils");
+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; } /** @hidden */ /** */
+var WEAK_RETAIN_TIME_MS = 10000;
+var ObjectPool = /*#__PURE__*/function () {
+  /** @hidden */
+  function ObjectPool(ctor) {
+    (0, _classCallCheck2.default)(this, ObjectPool);
+    /** @internal */
+    (0, _defineProperty2.default)(this, "_objectsByKey", {});
+    /** @internal */
+    (0, _defineProperty2.default)(this, "_weakObjectsByKey", {});
+    /** @internal */
+    (0, _defineProperty2.default)(this, "_Ctor", void 0);
+    this._Ctor = ctor;
+  }
+
+  // we have two different ways we can register an object for reuse - weak and strong. This one,
+  // strong, will make sure that the object is kept in the pool until it is explicitly removed.
+  /** @hidden */
+  return (0, _createClass2.default)(ObjectPool, [{
+    key: "registerObjectForReuseStrong",
+    value: function registerObjectForReuseStrong(object) {
+      this._unregisterObjectForReuseWeakIfExists(object);
+      var objectKey = object.__poolKey;
+      var pooledObjects = this._objectsByKey[objectKey];
+      if (pooledObjects) {
+        pooledObjects.push(object);
+      } else {
+        this._objectsByKey[objectKey] = [object];
+      }
+    }
+    /** @hidden */
+  }, {
+    key: "unregisterObjectForReuseStrong",
+    value: function unregisterObjectForReuseStrong(object) {
+      var objectKey = object.__poolKey;
+      var pooledObjects = this._objectsByKey[objectKey];
+      (0, _error_utils.invariant)(pooledObjects, 'pooledObjects');
+      var index = pooledObjects.indexOf(object);
+      (0, _error_utils.invariant)(index !== -1, 'object not registered');
+      pooledObjects.splice(index, 1);
+      if (pooledObjects.length === 0) {
+        // `delete` causes de-opts, which slows down subsequent reads,
+        // so set to undefined instead (unverified that this is actually faster).
+        this._objectsByKey[objectKey] = undefined;
+      }
+    }
+
+    // we have two different ways we can register an object for reuse - weak and strong. This one,
+    // weak, will automatically unregister the object after a few seconds go by without it being
+    // used.
+    /** @hidden */
+  }, {
+    key: "_registerObjectForReuseWeak",
+    value: function _registerObjectForReuseWeak(object) {
+      var objectKey = object.__poolKey;
+      var pooledObjects = this._weakObjectsByKey[objectKey];
+      var toStore = {
+        object,
+        timeoutId: setTimeout(() => this._unregisterObjectForReuseWeakIfExists(object), WEAK_RETAIN_TIME_MS)
+      };
+      if (pooledObjects) {
+        pooledObjects.push(toStore);
+      } else {
+        this._weakObjectsByKey[objectKey] = [toStore];
+      }
+    }
+    /** @internal */
+  }, {
+    key: "_unregisterObjectForReuseWeakIfExists",
+    value: function _unregisterObjectForReuseWeakIfExists(object) {
+      var objectKey = object.__poolKey;
+      var pooledObjects = this._weakObjectsByKey[objectKey];
+      if (!pooledObjects) {
+        return false;
+      }
+      var index = pooledObjects.findIndex(stored => stored.object === object);
+      if (index === -1) {
+        return false;
+      }
+      var stored = pooledObjects[index];
+      clearTimeout(stored.timeoutId);
+      pooledObjects.splice(index, 1);
+      if (pooledObjects.length === 0) {
+        // `delete` causes de-opts, which slows down subsequent reads,
+        // so set to undefined instead (unverified that this is actually faster).
+        this._weakObjectsByKey[objectKey] = undefined;
+      }
+      return true;
+    }
+
+    /** @internal */
+  }, {
+    key: "_getObjectForReuseStrong",
+    value: function _getObjectForReuseStrong(key) {
+      var pooledObjects = this._objectsByKey[key];
+      if (pooledObjects) {
+        // We expect that there won't be too many QueryResults for a given
+        // model, so iterating over them should be okay. If this assumption
+        // ends up being wrong, we can hash the opts or something.
+        var _iterator = _createForOfIteratorHelper(pooledObjects),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var object = _step.value;
+            if (object.__poolKey === key) {
+              return object;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      return null;
+    }
+    /** @internal */
+  }, {
+    key: "_getObjectForReuseWeak",
+    value: function _getObjectForReuseWeak(key) {
+      var pooledObjects = this._weakObjectsByKey[key];
+      if (!pooledObjects) {
+        return null;
+      }
+      var stored = pooledObjects.find(_ref => {
+        var object = _ref.object;
+        return object.__poolKey === key;
+      });
+      if (!stored) {
+        return null;
+      }
+      var object = stored.object,
+        timeoutId = stored.timeoutId;
+
+      // reset the timer on this object if it's reused
+      clearTimeout(timeoutId);
+      stored.timeoutId = setTimeout(() => this._unregisterObjectForReuseWeakIfExists(object), WEAK_RETAIN_TIME_MS);
+      return object;
+    }
+    /** @hidden */
+  }, {
+    key: "getObjectForReuse",
+    value: function getObjectForReuse() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var newObject = new this._Ctor(...args);
+      var key = newObject.__poolKey;
+      var existingObject = this._getObjectForReuseStrong(key) || this._getObjectForReuseWeak(key);
+      if (existingObject) {
+        return existingObject;
+      }
+      this._registerObjectForReuseWeak(newObject);
+      return newObject;
+    }
+  }]);
+}();
+var _default = exports.default = ObjectPool;

package/dist/cjs/base/models/record.js

@@ -0,0 +1,304 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.string.starts-with.js");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+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 _record_core = require("../../shared/models/record_core");
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+var _color_utils = _interopRequireDefault(require("../../shared/color_utils"));
+var _linked_records_query_result = _interopRequireDefault(require("./linked_records_query_result"));
+var _object_pool = _interopRequireDefault(require("./object_pool"));
+var _record_query_result = _interopRequireDefault(require("./record_query_result"));
+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; })(); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } /** @module @airtable/blocks/models: Record */ /** */
+var WatchableRecordKeys = Object.freeze(_objectSpread(_objectSpread({}, _record_core.WatchableRecordKeysCore), {}, {
+  commentCount: 'commentCount'
+}));
+// TODO: load cell values in field when this is watched? This will
+// cause the CellRenderer component to load cell values, which seems okay,
+// but needs a little more thought.
+var WatchableCellValueInFieldKeyPrefix = 'cellValueInField:';
+// TODO: load view data when this is watched. see previous comment.
+var WatchableColorInViewKeyPrefix = 'colorInView:';
+/**
+ * Any key within record that can be watched:
+ * - `'name'`
+ * - `'commentCount'`
+ * - `'cellValues'`
+ * - `'cellValueInField:' + someFieldId`
+ * - `'colorInView:' + someViewId`
+ */
+/**
+ * Model class representing a record in a table.
+ *
+ * Do not instantiate. You can get instances of this class by calling `table.selectRecords`
+ * or `view.selectRecords` and using the resulting {@link RecordQueryResult}.
+ *
+ * @docsPath models/Record
+ */
+var Record = /*#__PURE__*/function (_RecordCore) {
+  /**
+   * @internal
+   */
+  function Record(sdk, parentRecordStore, parentTable, recordId) {
+    var _this;
+    (0, _classCallCheck2.default)(this, Record);
+    _this = _callSuper(this, Record, [sdk, parentRecordStore, parentTable, recordId]);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "__linkedRecordsQueryResultPool", void 0);
+    _this.__linkedRecordsQueryResultPool = new _object_pool.default(_linked_records_query_result.default);
+    return _this;
+  }
+  /**
+   * @internal
+   */
+  (0, _inherits2.default)(Record, _RecordCore);
+  return (0, _createClass2.default)(Record, [{
+    key: "_getViewMatching",
+    value: function _getViewMatching(viewOrViewIdOrViewName) {
+      return this.parentTable.__getViewMatching(viewOrViewIdOrViewName);
+    }
+
+    /**
+     * 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);
+      (0, _error_utils.invariant)(this._parentRecordStore.areCellValuesLoadedForFieldId(field.id), 'Cell values for field %s are not loaded', field.id);
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "getCellValueAsString", this).call(this, field.id);
+    }
+  }, {
+    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);
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "_getRawCellValue", this).call(this, field);
+    }
+
+    /**
+     * Returns a URL that is suitable for rendering an attachment on the current client.
+     * The URL that is returned will only work for the current user.
+     *
+     * @param attachmentId The ID of the attachment.
+     * @param attachmentUrl The attachment's URL (which is not suitable for rendering on the client).
+     * @example
+     * ```js
+     * import React from 'react';
+     *
+     * function RecordAttachments(props) {
+     *     const {record, attachmentField} = props;
+     *     const attachmentCellValue = record.getCellValue(attachmentField);
+     *     if (attachmentCellValue === null) {
+     *         return null;
+     *     }
+     *     return (
+     *         <div>
+     *             {attachmentCellValue.map(attachmentObj => {
+     *                 const clientUrl =
+     *                     record.getAttachmentClientUrlFromCellValueUrl(
+     *                         attachmentObj.id,
+     *                         attachmentObj.url
+     *                     );
+     *                 return (
+     *                     <img key={attachmentObj.id} src={clientUrl} width={200} />
+     *                 );
+     *             })}
+     *         </div>
+     *     );
+     * }
+     * ```
+     */
+  }, {
+    key: "getAttachmentClientUrlFromCellValueUrl",
+    value: function getAttachmentClientUrlFromCellValueUrl(attachmentId, attachmentUrl) {
+      var airtableInterface = this._sdk.__airtableInterface;
+      var appInterface = this._sdk.__appInterface;
+      return airtableInterface.urlConstructor.getAttachmentClientUrl(appInterface, attachmentId, attachmentUrl);
+    }
+    /**
+     * Gets the color of this record in a given view, or null if the record has no color in that
+     * view.
+     *
+     * Can be watched with the 'colorInView:${ViewId}' key.
+     *
+     * @param viewOrViewIdOrViewName The view (or view ID or view name) to use for record coloring.
+     */
+  }, {
+    key: "getColorInView",
+    value: function getColorInView(viewOrViewIdOrViewName) {
+      var view = this._getViewMatching(viewOrViewIdOrViewName);
+      return this._parentRecordStore.getViewDataStore(view.id).getRecordColor(this);
+    }
+    /**
+     * Gets the CSS hex string for this record in a given view, or null if the record has no color
+     * in that view.
+     *
+     * Can be watched with the 'colorInView:${ViewId}' key.
+     *
+     * @param viewOrViewIdOrViewName The view (or view ID or view name) to use for record coloring.
+     */
+  }, {
+    key: "getColorHexInView",
+    value: function getColorHexInView(viewOrViewIdOrViewName) {
+      var color = this.getColorInView(viewOrViewIdOrViewName);
+      if (!color) {
+        return null;
+      }
+      return _color_utils.default.getHexForColor(color);
+    }
+    /**
+     * Select records referenced in a `multipleRecordLinks` cell value. Returns a query result
+     * containing the records in the given `multipleRecordLinks` field.
+     * See {@link RecordQueryResult} for more.
+     *
+     * @param fieldOrFieldIdOrFieldName The `multipleRecordLinks` field (or field ID or field name) to use.
+     * @param opts Options for the query, such as sorts and fields.
+     */
+  }, {
+    key: "selectLinkedRecordsFromCell",
+    value: function selectLinkedRecordsFromCell(fieldOrFieldIdOrFieldName) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName);
+      var linkedTableId = field.options && field.options.linkedTableId;
+      (0, _error_utils.invariant)(typeof linkedTableId === 'string', 'linkedTableId must be set');
+      var linkedTable = this._sdk.base.getTableById(linkedTableId);
+      var linkedRecordStore = this._sdk.base.__getRecordStore(linkedTableId);
+      var normalizedOpts = _record_query_result.default._normalizeOpts(linkedTable, linkedRecordStore, opts);
+      return this.__linkedRecordsQueryResultPool.getObjectForReuse(this, field, normalizedOpts, this._sdk);
+    }
+    /**
+     * Select and load records referenced in a `multipleRecordLinks` cell value. Returns a query result
+     * promise containing the records in the given `multipleRecordLinks` field.
+     * See {@link RecordQueryResult} for more.
+     *
+     * Remember to call `queryResult.unloadData` once you're finished with the query.
+     *
+     * @param fieldOrFieldIdOrFieldName The `multipleRecordLinks` field (or field ID or field name) to use.
+     * @param opts Options for the query, such as sorts and fields.
+     */
+  }, {
+    key: "selectLinkedRecordsFromCellAsync",
+    value: (function () {
+      var _selectLinkedRecordsFromCellAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(fieldOrFieldIdOrFieldName) {
+        var opts,
+          queryResult,
+          _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              opts = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+              queryResult = this.selectLinkedRecordsFromCell(fieldOrFieldIdOrFieldName, opts);
+              _context.next = 4;
+              return queryResult.loadDataAsync();
+            case 4:
+              return _context.abrupt("return", queryResult);
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function selectLinkedRecordsFromCellAsync(_x) {
+        return _selectLinkedRecordsFromCellAsync.apply(this, arguments);
+      }
+      return selectLinkedRecordsFromCellAsync;
+    }()
+    /**
+     * The URL for the record. You can visit this URL in the browser to be taken to the record in the Airtable UI.
+     *
+     * @example
+     * ```js
+     * console.log(myRecord.url);
+     * // => 'https://airtable.com/appxxxxxxxxxxxxxx/tblxxxxxxxxxxxxxx/recxxxxxxxxxxxxxx'
+     * ```
+     */
+    )
+  }, {
+    key: "url",
+    get: function get() {
+      return this._sdk.__airtableInterface.urlConstructor.getRecordUrl(this.id, this.parentTable.id);
+    }
+    /**
+     * The number of comments on this record.
+     *
+     * @example
+     * ```js
+     * const commentCount = myRecord.commentCount;
+     * const isSingular = commentCount === 1;
+     * console.log(
+     *     `This record has ${commentCount} comment${isSingular ? '' : 's'}`
+     * );
+     * ```
+     */
+  }, {
+    key: "commentCount",
+    get: function get() {
+      return this._data.commentCount;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__triggerOnChangeForDirtyPaths",
+    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "__triggerOnChangeForDirtyPaths", this).call(this, dirtyPaths);
+      var cellValuesByFieldId = dirtyPaths.cellValuesByFieldId,
+        commentCount = dirtyPaths.commentCount;
+      if (cellValuesByFieldId && !(0, _private_utils.isObjectEmpty)(cellValuesByFieldId)) {
+        for (var _i = 0, _Object$keys = Object.keys(cellValuesByFieldId); _i < _Object$keys.length; _i++) {
+          var fieldId = _Object$keys[_i];
+          this._onChange(WatchableCellValueInFieldKeyPrefix + fieldId, fieldId);
+        }
+      }
+      if (commentCount) {
+        this._onChange(WatchableRecordKeys.commentCount);
+      }
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__triggerOnChangeForRecordColorInViewId",
+    value: function __triggerOnChangeForRecordColorInViewId(viewId) {
+      this._onChange(WatchableColorInViewKeyPrefix + viewId);
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableRecordKeys, key) || key.startsWith(WatchableCellValueInFieldKeyPrefix) || key.startsWith(WatchableColorInViewKeyPrefix);
+    }
+  }]);
+}(_record_core.RecordCore);
+/** @internal */
+(0, _defineProperty2.default)(Record, "_className", 'Record');
+var _default = exports.default = Record;

package/dist/cjs/base/models/record_coloring.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serialize = exports.modes = exports.ModeTypes = void 0;
+/** @module @airtable/blocks/models: Record Coloring */ /** */
+
+// TODO(emma): update this to be an enum
+/**
+ * An enum of the different types of {@link recordColoring.modes}
+ *
+ * @hidden
+ * @alias recordColoring.ModeTypes
+ */
+var ModeTypes = exports.ModeTypes = {
+  /**
+   * @alias recordColoring.ModeTypes.NONE
+   */
+  NONE: 'none',
+  /**
+   * @alias recordColoring.ModeTypes.BY_SELECT_FIELD
+   */
+  BY_SELECT_FIELD: 'bySelectField',
+  /**
+   * @alias recordColoring.ModeTypes.BY_VIEW
+   */
+  BY_VIEW: 'byView'
+};
+
+/**
+ * @hidden
+ */
+
+/** */
+
+/** */
+
+/** */
+
+/** */
+
+var serialize = mode => {
+  var result = mode.type;
+  if (mode.type === ModeTypes.BY_SELECT_FIELD) {
+    result += "-".concat(mode.selectField.id);
+  } else if (mode.type === ModeTypes.BY_VIEW) {
+    result += "-".concat(mode.view.id);
+  }
+  return result;
+};
+
+/**
+ * Record coloring config creators.
+ *
+ * @alias recordColoring.modes
+ * @example
+ * ```js
+ * import {recordColoring} from '@airtable/blocks/models';
+ * import {useRecords} from '@airtable/blocks/ui';
+ *
+ * // no record coloring:
+ * const recordColorMode = recordColoring.modes.none();
+ * // color by select field:
+ * const recordColorMode = recordColoring.modes.bySelectField(someSelectField);
+ * // color from view:
+ * const recordColorMode = recordColoring.modes.byView(someView);
+ *
+ * // with useRecords:
+ * const queryResult = useRecords(table, { recordColorMode })
+ *
+ * // with a query result:
+ * const queryResult = table.selectRecords({ recordColorMode });
+ * ```
+ */
+exports.serialize = serialize;
+var modes = exports.modes = {
+  /**
+   * Returns a {@link RecordColorMode} that represents no record coloring.
+   *
+   * @alias recordColoring.modes.none
+   */
+  none() {
+    return {
+      type: ModeTypes.NONE
+    };
+  },
+  /**
+   * Returns a {@link RecordColorMode} that colors records by the specified Select field.
+   *
+   * @alias recordColoring.modes.bySelectField
+   * @param selectField
+   */
+  bySelectField(selectField) {
+    return {
+      type: ModeTypes.BY_SELECT_FIELD,
+      selectField
+    };
+  },
+  /**
+   * Returns a {@link RecordColorMode} that colors records by the specified View.
+   *
+   * @alias recordColoring.modes.byView
+   * @param view
+   */
+  byView(view) {
+    return {
+      type: ModeTypes.BY_VIEW,
+      view
+    };
+  }
+};