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

package/dist/cjs/base/viewport.js

@@ -0,0 +1,397 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.includes.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 _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 _watchable = _interopRequireDefault(require("../shared/watchable"));
+var _private_utils = require("../shared/private_utils");
+var _error_utils = require("../shared/error_utils");
+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; })(); } /** @module @airtable/blocks: viewport */ /** */
+var WatchableViewportKeys = Object.freeze({
+  isFullscreen: 'isFullscreen',
+  size: 'size',
+  minSize: 'minSize',
+  maxFullscreenSize: 'maxFullscreenSize'
+});
+
+/**
+ * Watchable keys in {@link Viewport}.
+ * - `isFullscreen`
+ * - `size`
+ * - `minSize`
+ * - `maxFullscreenSize`
+ */
+
+/** */
+
+var compareWithNulls = (a, b, compare) => {
+  if (a !== null && b !== null) {
+    return compare(a, b);
+  }
+  if (a === null) {
+    return b;
+  }
+  if (b === null) {
+    return a;
+  }
+  return null;
+};
+/**
+ * Information about the current viewport
+ *
+ * The {@link useViewport} hook is the recommend way to watch for viewport changes
+ * button, but you can also use it directly.
+ *
+ * @example
+ * ```js
+ * import {viewport} from '@airtable/blocks';
+ * ```
+ * @docsPath models/Viewport
+ */
+var Viewport = /*#__PURE__*/function (_Watchable) {
+  /** @internal */
+  function Viewport(isFullscreen, airtableInterface) {
+    var _this;
+    (0, _classCallCheck2.default)(this, Viewport);
+    _this = _callSuper(this, Viewport);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_isFullscreen", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_airtableInterface", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_sizeWatchCount", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_onSizeChangeDebounced", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_minSizes", new Set());
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_maxFullscreenSizes", new Set());
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_cachedMaxFullscreenSize", null);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_cachedMinSize", null);
+    _this._isFullscreen = isFullscreen;
+    _this._airtableInterface = airtableInterface;
+
+    // When size is watched, we'll increment this counter, and we'll decrement
+    // it when it is unwatched and the counter is at 0. This way we can lazily
+    // add an event listener for window resize and remove it when nobody is
+    // listening anymore.
+    _this._sizeWatchCount = 0;
+    _this._onSizeChangeDebounced = (0, _private_utils.debounce)(_this._onSizeChange.bind(_this), 200);
+
+    // whenever maxFullscreenSize changes, we want to sync it back to the
+    // containing frame
+    _this.watch(WatchableViewportKeys.maxFullscreenSize, () => {
+      _this._airtableInterface.setFullscreenMaxSize(_this.maxFullscreenSize);
+    });
+    return _this;
+  }
+  /**
+   * Request to enter fullscreen mode.
+   *
+   * May fail if another extension is fullscreen or this extension doesn't have
+   * permission to fullscreen itself. Watch `isFullscreen` to know if the
+   * request succeeded.
+   */
+  (0, _inherits2.default)(Viewport, _Watchable);
+  return (0, _createClass2.default)(Viewport, [{
+    key: "enterFullscreenIfPossible",
+    value: function enterFullscreenIfPossible() {
+      this._airtableInterface.enterFullscreen();
+    }
+    /** Request to exit fullscreen mode */
+  }, {
+    key: "exitFullscreen",
+    value: function exitFullscreen() {
+      this._airtableInterface.exitFullscreen();
+    }
+
+    /**
+     * The maximum dimensions of the extension when it is in
+     * fullscreen mode. Returns the smallest set of dimensions added with
+     * {@link addMaxFullscreenSize}.
+     *
+     * If `width` or `height` is null, it means there is
+     * no max size constraint on that dimension. If `maxFullscreenSize` would be
+     * smaller than {@link minSize}, it is constrained to be at least `minSize`.
+     */
+  }, {
+    key: "maxFullscreenSize",
+    get: function get() {
+      if (!this._cachedMaxFullscreenSize) {
+        var maxFullscreenSize = Array.from(this._maxFullscreenSizes).reduce((memo, size) => ({
+          width: compareWithNulls(memo.width, size.width, Math.min),
+          height: compareWithNulls(memo.height, size.height, Math.min)
+        }), {
+          width: null,
+          height: null
+        });
+        var minSize = this.minSize;
+        this._cachedMaxFullscreenSize = {
+          width: maxFullscreenSize.width !== null && minSize.width !== null ? Math.max(maxFullscreenSize.width, minSize.width) : maxFullscreenSize.width,
+          height: maxFullscreenSize.height !== null && minSize.height !== null ? Math.max(maxFullscreenSize.height, minSize.height) : maxFullscreenSize.height
+        };
+      }
+      return this._cachedMaxFullscreenSize;
+    }
+
+    /**
+     * Add a maximum fullscreen size constraint. Use `.maxFullscreenSize` to get
+     * the aggregate of all added constraints.
+     *
+     * Returns a function that can be called to remove the fullscreen size constraint that was added.
+     *
+     * @param sizeConstraint The width and height constraints to add. Both
+     * `width` and `height` are optional - if either is set to null, that means
+     * there is no max size in that dimension.
+     */
+  }, {
+    key: "addMaxFullscreenSize",
+    value: function addMaxFullscreenSize(sizeConstraint) {
+      var width = sizeConstraint.width,
+        height = sizeConstraint.height;
+      var size = Object.freeze({
+        width: typeof width === 'number' ? width : null,
+        height: typeof height === 'number' ? height : null
+      });
+      this._cachedMaxFullscreenSize = null;
+      this._maxFullscreenSizes.add(size);
+      this._onChange(WatchableViewportKeys.maxFullscreenSize);
+      return () => {
+        (0, _error_utils.invariant)(this._maxFullscreenSizes.has(size), 'UnsetFn can only be called once');
+        this._cachedMaxFullscreenSize = null;
+        this._maxFullscreenSizes.delete(size);
+        this._onChange(WatchableViewportKeys.maxFullscreenSize);
+      };
+    }
+
+    /**
+     * The minimum dimensions of the extension - if the viewport gets smaller than this
+     * size, an overlay will be shown asking the user to resize the extension to be bigger.
+     *
+     * The largest set of dimensions added with addMinSize. If `width` or `height` is null, it means
+     * there is no minSize constraint on that dimension.
+     */
+  }, {
+    key: "minSize",
+    get: function get() {
+      if (!this._cachedMinSize) {
+        this._cachedMinSize = Array.from(this._minSizes).reduce((memo, size) => ({
+          width: compareWithNulls(memo.width, size.width, Math.max),
+          height: compareWithNulls(memo.height, size.height, Math.max)
+        }), {
+          width: null,
+          height: null
+        });
+      }
+      return this._cachedMinSize;
+    }
+
+    /**
+     * Add a minimum frame size constraint. Use `.minSize`` to get the aggregate
+     * of all added constraints.
+     *
+     * Upon adding a constraint, if the extension is focused and the frame is smaller than the
+     * minimum size, the extension will enter fullscreen mode.
+     *
+     * Returns a function that can be called to remove the  size constraint that was added.
+     *
+     * @param sizeConstraint The width and height constraints to add. Both `width`
+     * and `height` are optional - if either is set to null, that means there is
+     * no min size in that dimension.
+     */
+  }, {
+    key: "addMinSize",
+    value: function addMinSize(sizeConstraint) {
+      var width = sizeConstraint.width,
+        height = sizeConstraint.height;
+      var size = Object.freeze({
+        width: typeof width === 'number' ? width : null,
+        height: typeof height === 'number' ? height : null
+      });
+      this._cachedMinSize = null;
+      // min size is also a constraint on maxFullscreenSize:
+      this._cachedMaxFullscreenSize = null;
+      this._minSizes.add(size);
+      this._onChange(WatchableViewportKeys.minSize);
+      this._onChange(WatchableViewportKeys.maxFullscreenSize);
+      if (this.isSmallerThanMinSize) {
+        this.enterFullscreenIfPossible();
+      }
+      return () => {
+        (0, _error_utils.invariant)(this._minSizes.has(size), 'UnsetFn can only be called once');
+        this._cachedMinSize = null;
+        this._cachedMaxFullscreenSize = null;
+        this._minSizes.delete(size);
+        this._onChange(WatchableViewportKeys.minSize);
+        // min size is also a constraint on maxFullscreenSize:
+        this._onChange(WatchableViewportKeys.maxFullscreenSize);
+      };
+    }
+
+    /**
+     * `true` if the extension frame is smaller than `minSize`, `false` otherwise.
+     */
+  }, {
+    key: "isSmallerThanMinSize",
+    get: function get() {
+      var _this$size = this.size,
+        width = _this$size.width,
+        height = _this$size.height;
+      var isWidthTooSmall = this.minSize.width !== null && this.minSize.width > width;
+      var isHeightTooSmall = this.minSize.height !== null && this.minSize.height > height;
+      return isWidthTooSmall || isHeightTooSmall;
+    }
+    /**
+     * `true` if the extension is fullscreen, `false` otherwise.
+     */
+  }, {
+    key: "isFullscreen",
+    get: function get() {
+      return this._isFullscreen;
+    }
+    /**
+     * The current size of the extension frame.
+     *
+     * Can be watched.
+     */
+  }, {
+    key: "size",
+    get: function get() {
+      return {
+        width: window.innerWidth,
+        height: window.innerHeight
+      };
+    }
+    /**
+     * Get notified of changes to the viewport.
+     *
+     * Watchable keys are:
+     * - `'isFullscreen'`
+     * - `'size'`
+     * - `'minSize'`
+     * - `'maxFullscreenSize'`
+     *
+     * Every call to `.watch` should have a matching call to `.unwatch`.
+     *
+     * Returns the array of keys that were watched.
+     *
+     * @param keys the keys to watch
+     * @param callback a function to call when those keys change
+     * @param context an optional context for `this` in `callback`.
+     */
+  }, {
+    key: "watch",
+    value: function watch(keys, callback, context) {
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(Viewport.prototype), "watch", this).call(this, keys, callback, context);
+      if (validKeys.includes(WatchableViewportKeys.size)) {
+        if (this._sizeWatchCount === 0) {
+          window.addEventListener('resize', this._onSizeChangeDebounced, false);
+        }
+        this._sizeWatchCount++;
+      }
+      return validKeys;
+    }
+    /**
+     * Unwatch keys watched with `.watch`.
+     *
+     * Should be called with the same arguments given to `.watch`.
+     *
+     * Returns the array of keys that were unwatched
+     *
+     * @param keys the keys to unwatch
+     * @param callback the function passed to `.watch` for these keys
+     * @param context the context that was passed to `.watch` for this `callback`
+     */
+  }, {
+    key: "unwatch",
+    value: function unwatch(keys, callback, context) {
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(Viewport.prototype), "unwatch", this).call(this, keys, callback, context);
+      if (validKeys.includes(WatchableViewportKeys.size)) {
+        this._sizeWatchCount--;
+        if (this._sizeWatchCount === 0) {
+          window.removeEventListener('resize', this._onSizeChangeDebounced, false);
+        }
+      }
+      return validKeys;
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__onEnterFullscreen",
+    value: function __onEnterFullscreen() {
+      this._isFullscreen = true;
+      this._onChange(WatchableViewportKeys.isFullscreen);
+      this._onChange(WatchableViewportKeys.size);
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__onExitFullscreen",
+    value: function __onExitFullscreen() {
+      this._isFullscreen = false;
+      this._onChange(WatchableViewportKeys.isFullscreen);
+      this._onChange(WatchableViewportKeys.size);
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "__focus",
+    value: function __focus() {
+      var _document = document,
+        body = _document.body,
+        activeElement = _document.activeElement;
+      // See comment in BlockFrame.focusIframe for why we do this.
+      if (activeElement && activeElement !== body) {
+        // If there's already an activeElement, re-focus it.
+        activeElement.focus();
+      } else if (body) {
+        // If there isn't an activeElement, create a dummy input
+        // to capture focus.
+        var input = document.createElement('input');
+        body.appendChild(input);
+        input.focus();
+        input.remove();
+      }
+    }
+    /**
+     * @internal
+     */
+  }, {
+    key: "_onSizeChange",
+    value: function _onSizeChange() {
+      this._onChange(WatchableViewportKeys.size);
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableViewportKeys, key);
+    }
+  }]);
+}(_watchable.default);
+/** @internal */
+(0, _defineProperty2.default)(Viewport, "_className", 'Viewport');
+var _default = exports.default = Viewport;

package/dist/cjs/injected/airtable_interface.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getAirtableInterface;
+var _error_utils = require("../shared/error_utils");
+var AIRTABLE_INTERFACE_VERSION = 0;
+var airtableInterface = null;
+var missingAirtableInterfaceErrorMessage = ['Error: Extension environment misconfigured', '\n\n', 'Airtable Extensions can only run in the presence of an Airtable Base. If you ', 'are trying to run your Extension with a Base hosted on airtable.com, then be ', 'sure you are using the Airtable CLI to serve your code and accessing it ', 'through a Custom Extension installed inside a Base on airtable.com.', '\n\n', 'If you are trying to run automated tests for your Extension, then make sure ', 'you have loaded the `@airtable/testing-library` module *before* the ', '`@airtable/blocks` module.'].join('');
+
+/** @hidden */
+function getAirtableInterface() {
+  var getAirtableInterfaceAtVersion = window.__getAirtableInterfaceAtVersion;
+  if (!airtableInterface) {
+    if (!getAirtableInterfaceAtVersion) {
+      throw (0, _error_utils.spawnError)(missingAirtableInterfaceErrorMessage);
+    }
+    airtableInterface = getAirtableInterfaceAtVersion(AIRTABLE_INTERFACE_VERSION);
+  }
+  return airtableInterface;
+}

package/dist/cjs/interface/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.__reset = __reset;
+exports.runInfo = exports.reload = exports.installationId = exports.globalConfig = exports.base = exports.__sdk = void 0;
+var _warning = require("../shared/warning");
+var _airtable_interface = _interopRequireDefault(require("../injected/airtable_interface"));
+var _sdk2 = require("./sdk");
+var _initialize_block = require("./ui/initialize_block");
+/** @internal */
+var __sdk;
+var base;
+var globalConfig;
+var installationId;
+var reload;
+var runInfo;
+
+/** @internal */
+function __reset() {
+  exports.__sdk = __sdk = new _sdk2.InterfaceBlockSdk((0, _airtable_interface.default)());
+  // The following injections are necessary to allow the referenced modules
+  // to be imported directly by consumer code while also avoiding cycles in
+  // the module dependency graph.
+  var _sdk = __sdk;
+  exports.base = base = _sdk.base;
+  exports.globalConfig = globalConfig = _sdk.globalConfig;
+  exports.installationId = installationId = _sdk.installationId;
+  exports.reload = reload = _sdk.reload;
+  exports.runInfo = runInfo = _sdk.runInfo;
+  (0, _initialize_block.__injectSdkIntoInitializeBlock)(__sdk);
+  (0, _warning.__injectSdkIntoWarning)(__sdk);
+}
+__reset();

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

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Base = 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 _base_core = require("../../shared/models/base_core");
+var _table = require("./table");
+var _record_store = require("./record_store");
+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; })(); }
+/**
+ * Model class representing a base.
+ *
+ * If you want the base model to automatically recalculate whenever the base schema changes, try the
+ * {@link useBase} hook.
+ *
+ * @docsPath models/Base
+ */
+var Base = exports.Base = /*#__PURE__*/function (_BaseCore) {
+  function Base() {
+    (0, _classCallCheck2.default)(this, Base);
+    return _callSuper(this, Base, arguments);
+  }
+  (0, _inherits2.default)(Base, _BaseCore);
+  return (0, _createClass2.default)(Base, [{
+    key: "_constructTable",
+    value: /** @internal */
+    function _constructTable(tableId) {
+      var recordStore = this.__getRecordStore(tableId);
+      return new _table.Table(this, recordStore, tableId, this._sdk);
+    }
+
+    /** @internal */
+  }, {
+    key: "_constructRecordStore",
+    value: function _constructRecordStore(sdk, tableId) {
+      return new _record_store.RecordStore(sdk, tableId);
+    }
+
+    /** @internal */
+  }, {
+    key: "_iterateTableIds",
+    value: function _iterateTableIds() {
+      return Object.keys(this._data.tablesById);
+    }
+  }]);
+}(_base_core.BaseCore);

package/dist/cjs/interface/models/field.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Field = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+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 _field_core = require("../../shared/models/field_core");
+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; })(); }
+/**
+ * Model class representing a field in a table.
+ *
+ * @example
+ * ```js
+ * import {useBase} from '@airtable/blocks/interface/ui';
+ *
+ * function App() {
+ *     const base = useBase();
+ *     const table = base.getTableByName('Table 1');
+ *     const field = table.getFieldByName('Name');
+ *     console.log('The type of this field is', field.type);
+ * }
+ * ```
+ * @docsPath models/Field
+ */
+var Field = exports.Field = /*#__PURE__*/function (_FieldCore) {
+  function Field() {
+    (0, _classCallCheck2.default)(this, Field);
+    return _callSuper(this, Field, arguments);
+  }
+  (0, _inherits2.default)(Field, _FieldCore);
+  return (0, _createClass2.default)(Field);
+}(_field_core.FieldCore);
+/** @internal */
+(0, _defineProperty2.default)(Field, "_className", 'Field');

package/dist/cjs/interface/models/mutations.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Mutations = 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 _mutations_core = require("../../shared/models/mutations_core");
+var _error_utils = require("../../shared/error_utils");
+var _mutations = require("../types/mutations");
+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; })(); }
+/** @hidden */
+var Mutations = exports.Mutations = /*#__PURE__*/function (_MutationsCore) {
+  function Mutations() {
+    (0, _classCallCheck2.default)(this, Mutations);
+    return _callSuper(this, Mutations, arguments);
+  }
+  (0, _inherits2.default)(Mutations, _MutationsCore);
+  return (0, _createClass2.default)(Mutations, [{
+    key: "_doesMutationExceedBatchSizeLimit",
+    value: /** @internal */
+    function _doesMutationExceedBatchSizeLimit(mutation) {
+      switch (mutation.type) {
+        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+          return mutation.updates.length > _mutations_core.MUTATIONS_MAX_BATCH_SIZE;
+        default:
+          throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation.type, 'type');
+      }
+    }
+    /** @internal */
+  }, {
+    key: "_assertMutationIsValid",
+    value: function _assertMutationIsValid(mutation) {
+      switch (mutation.type) {
+        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+          // globalConfig update is a special case: globalConfig handles validation before
+          // invoking this mutation, since it relies on internal state to validate the
+          // paths being set.
+          return;
+        default:
+          throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation.type, 'type');
+      }
+    }
+    /** @internal */
+  }, {
+    key: "_getOptimisticModelChangesForMutation",
+    value: function _getOptimisticModelChangesForMutation(mutation) {
+      switch (mutation.type) {
+        // The following branch is unreachable because this method's only
+        // call site is preceded by an explicit guard for this condition.
+        // istanbul ignore next
+        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+          throw (0, _error_utils.spawnError)('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
+        default:
+          throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation.type, 'type');
+      }
+    }
+  }]);
+}(_mutations_core.MutationsCore);

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

@@ -0,0 +1,46 @@
+"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.Record = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+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 _record_core = require("../../shared/models/record_core");
+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; }
+var WatchableRecordKeys = Object.freeze(_objectSpread({}, _record_core.WatchableRecordKeysCore));
+/**
+ * Any key within record that can be watched:
+ * - `'name'`
+ * - `'cellValues'`
+ */
+/**
+ * Model class representing a record in a table.
+ *
+ * Do not instantiate. You can get instances of this class by calling {@link useRecords}.
+ *
+ * @docsPath models/Record
+ */
+var Record = exports.Record = /*#__PURE__*/function (_RecordCore) {
+  function Record() {
+    (0, _classCallCheck2.default)(this, Record);
+    return _callSuper(this, Record, arguments);
+  }
+  (0, _inherits2.default)(Record, _RecordCore);
+  return (0, _createClass2.default)(Record);
+}(_record_core.RecordCore);
+/** @internal */
+(0, _defineProperty2.default)(Record, "_className", 'Record');