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

package/dist/cjs/base/perform_record_action.js

@@ -0,0 +1,257 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatchablePerformRecordActionKeys = exports.PerformRecordAction = void 0;
+exports.__injectSdkIntoPerformRecordAction = __injectSdkIntoPerformRecordAction;
+exports.registerRecordActionDataCallback = registerRecordActionDataCallback;
+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 _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _error_utils = require("../shared/error_utils");
+var _private_utils = require("../shared/private_utils");
+var _abstract_model_with_async_data = _interopRequireDefault(require("./models/abstract_model_with_async_data"));
+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 WatchablePerformRecordActionKeys = exports.WatchablePerformRecordActionKeys = Object.freeze({
+  // isDataLoaded must be a watchable key for a LoadableModel.
+  isDataLoaded: 'isDataLoaded',
+  recordActionData: 'recordActionData'
+});
+
+/** @hidden */
+
+/**
+ * Returned by {@link registerRecordActionDataCallback}. Call it to unregister the previously
+ * registered function. Do this before registering another function or unmounting the component.
+ * */
+/**
+ * This class exists to manage registering a callback to receive "Open block" / "Perform record
+ * action" messages.
+ * This is different to other message handlers (_registerHandlers) since the callback is specified
+ * by the block: it registers it during first render (vs the SDK registering during initialisation).
+ *
+ * On the liveapp side, we ensure that pending messages are held until the block registers the
+ * callback (or another message is sent). If there's a pending message, it is returned at
+ * registration.
+ *
+ * This class implements AbstractModelWithAsyncData in order to take advantage of useLoadable's
+ * suspense handling. "Loading" the model means registering the handler with liveapp. This allows us
+ * to suspend the block and return the initial pending message on first render.
+ *
+ * One difference is that _unloadData will not unregister the airtableInterface handler. We don't
+ * support unregistering it at this time for simplicity.
+ *
+ * This class is internal: users should use registerRecordActionDataCallback or useRecordActionData.
+ *
+ * @internal
+ * */
+var PerformRecordAction = exports.PerformRecordAction = /*#__PURE__*/function (_AbstractModelWithAsy) {
+  /** @hidden */
+  function PerformRecordAction(sdk, airtableInterface) {
+    var _this;
+    (0, _classCallCheck2.default)(this, PerformRecordAction);
+    _this = _callSuper(this, PerformRecordAction, [sdk, 'performRecordAction']);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_airtableInterface", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_hasRegisteredHandler", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_hasCompletedInitialDataLoad", void 0);
+    /**
+     * The data from the latest record action, or null if none have occurred yet.
+     *
+     * @internal */
+    (0, _defineProperty2.default)(_this, "recordActionData", void 0);
+    _this._airtableInterface = airtableInterface;
+    _this._hasRegisteredHandler = false;
+    _this._hasCompletedInitialDataLoad = false;
+    _this.recordActionData = null;
+    _this._handlePerformRecordAction = _this._handlePerformRecordAction.bind(_this);
+    return _this;
+  }
+
+  /** @internal */
+  (0, _inherits2.default)(PerformRecordAction, _AbstractModelWithAsy);
+  return (0, _createClass2.default)(PerformRecordAction, [{
+    key: "_handlePerformRecordAction",
+    value: /** @hidden */
+    function _handlePerformRecordAction(data) {
+      this.recordActionData = data;
+      this._onChange(WatchablePerformRecordActionKeys.recordActionData, data);
+    }
+
+    /**
+     * This accessor method is defined solely to satisfy the contract of the
+     * AbstractModel class.
+     *
+     * @internal */
+  }, {
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      return (0, _error_utils.invariant)(false, 'The `data` property of PerformRecordAction should not be referenced');
+    }
+
+    /**
+     * This accessor method is defined because the parent implementation uses _dataOrNullIfDeleted
+     *
+     * @inheritdoc */
+  }, {
+    key: "isDeleted",
+    get: function get() {
+      return false;
+    }
+
+    /**
+     * AbstractModelWithAsyncData implementation
+     */
+
+    /** @internal */
+  }, {
+    key: "_onChangeIsDataLoaded",
+    value: function _onChangeIsDataLoaded() {
+      this._onChange(WatchablePerformRecordActionKeys.isDataLoaded);
+
+      // Handle the case where there was a pending action whilst we were registering the handler.
+      // We only want to do this on the very initial load when we're actually registering the
+      // handler: avoid triggering this when the data is "unloaded" and "loaded".
+      if (!this._hasCompletedInitialDataLoad) {
+        this._hasCompletedInitialDataLoad = true;
+        if (this.recordActionData) {
+          this._handlePerformRecordAction(this.recordActionData);
+        }
+      }
+    }
+
+    /** @internal */
+  }, {
+    key: "_loadDataAsync",
+    value: (function () {
+      var _loadDataAsync2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this._hasRegisteredHandler) {
+                _context.next = 5;
+                break;
+              }
+              this._hasRegisteredHandler = true;
+              _context.next = 4;
+              return this._airtableInterface.fetchAndSubscribeToPerformRecordActionAsync(this._handlePerformRecordAction);
+            case 4:
+              this.recordActionData = _context.sent;
+            case 5:
+              return _context.abrupt("return", []);
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function _loadDataAsync() {
+        return _loadDataAsync2.apply(this, arguments);
+      }
+      return _loadDataAsync;
+    }() /** @internal */)
+  }, {
+    key: "_unloadData",
+    value: function _unloadData() {
+      // Hack: Don't do anything, since "loading" means registering a handler, and we don't need
+      // to unregister it.
+    }
+
+    /** @internal */
+  }], [{
+    key: "_isWatchableKey",
+    value: function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchablePerformRecordActionKeys, key);
+    }
+  }, {
+    key: "_shouldLoadDataForKey",
+    value: function _shouldLoadDataForKey(key) {
+      // Watching recordActionData will load data (aka register handler with liveapp) and trigger
+      // callback when done.
+      return key === WatchablePerformRecordActionKeys.recordActionData;
+    }
+  }]);
+}(_abstract_model_with_async_data.default);
+/**
+ * Registers a callback to handle "open block" / "perform record action" events (from button field).
+ *
+ * Returns a unsubscribe function that should be used to unregister the callback for cleanup on
+ * component unmount, or if you wish to register a different function.
+ *
+ * Also see {@link useRecordActionData}, which subscribes to the same events in a synchronous way.
+ *
+ * Your block will not receive "perform record action" events until a callback is registered -
+ * they're held until registration to ensure the block is ready to handle the event (e.g. has
+ * finished loading).
+ *
+ * Because of this, we recommend only registering a callback once, in your top level component -
+ * otherwise, messages could be received while not all callbacks have been successfully registered.
+ * Similarly, using both `registerRecordActionDataCallback` and `useRecordActionData` is not
+ * supported.
+ *
+ * You can test your block in development by sending "perform record action" events to your block
+ * in the "Advanced" panel of the block developer tools.
+ *
+ * After releasing your block, you can use it with a button field by choosing the "Open custom
+ * block" action and selecting your block.
+ *
+ * @example
+ * ```js
+ * import React, {useEffect, useState} from 'react';
+ * import {registerRecordActionDataCallback} from '@airtable/blocks/ui';
+ *
+ * function LatestRecordAction() {
+ *     const [recordActionData, setRecordActionData] = useState(null);
+ *
+ *     const callback = (data) => {
+ *         console.log('Record action received', data);
+ *         setRecordActionData(data);
+ *     }
+ *
+ *     useEffect(() => {
+ *         // Return the unsubscribe function so it's run on cleanup.
+ *         return registerRecordActionDataCallback(callback);
+ *     }, [callback]);
+ *
+ *     if (recordActionData === null) {
+ *         return <span>No events yet</span>;
+ *     }
+ *
+ *     return (
+ *         <ul>
+ *             <li>Record id: {recordActionData.recordId}</li>
+ *             <li>View id: {recordActionData.viewId}</li>
+ *             <li>Table id: {recordActionData.tableId}</li>
+ *         </ul>
+ *     );
+ * }
+ * ```
+ *
+ */
+function registerRecordActionDataCallback(callback) {
+  var _sdk2 = sdk,
+    performRecordAction = _sdk2.performRecordAction;
+  var wrappedCallback = (model, key, data) => {
+    callback(data);
+  };
+  performRecordAction.watch(WatchablePerformRecordActionKeys.recordActionData, wrappedCallback);
+  return () => performRecordAction.unwatch(WatchablePerformRecordActionKeys.recordActionData, wrappedCallback);
+}
+var sdk;
+
+// The application-level Sdk instance must be injected dynamically to avoid
+// circular dependencies at the time of module resolution.
+function __injectSdkIntoPerformRecordAction(_sdk) {
+  sdk = _sdk;
+}

package/dist/cjs/base/sdk.js

@@ -0,0 +1,230 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.weak-map.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 = void 0;
+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 _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _sdk_core = require("../shared/sdk_core");
+var _viewport = _interopRequireDefault(require("./viewport"));
+var _base = _interopRequireDefault(require("./models/base"));
+var _session = _interopRequireDefault(require("./models/session"));
+var _mutations = _interopRequireDefault(require("./models/mutations"));
+var _cursor = _interopRequireDefault(require("./models/cursor"));
+var _settings_button = _interopRequireDefault(require("./settings_button"));
+var _undo_redo = _interopRequireDefault(require("./undo_redo"));
+var _perform_record_action = require("./perform_record_action");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), 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; })(); } /** @hidden */ /** */ // NOTE: The version of React running in the Block SDK is controlled by the block.
+// The SDK should not make too many assumptions about which version of React or
+// ReactDOM is running.
+// HACK: make sure React.PropTypes is defined. If the block is using a newer
+// version of React, PropTypes won't be available, but a few SDK components
+// try to reference it. Once grepping React.PropTypes in hyperbase doesn't
+// return any matches, we can remove this hack.
+if (!React.PropTypes) {
+  React.PropTypes = _propTypes.default;
+}
+
+/** @hidden */
+
+/** @internal */
+function defaultUpdateBatcher(applyUpdates) {
+  applyUpdates();
+}
+
+/**
+ * We document this manually.
+ *
+ * @hidden
+ */
+var BaseBlockSdk = exports.default = /*#__PURE__*/function (_BlockSdkCore) {
+  /** @hidden */
+  function BaseBlockSdk(airtableInterface) {
+    var _this;
+    (0, _classCallCheck2.default)(this, BaseBlockSdk);
+    _this = _callSuper(this, BaseBlockSdk, [airtableInterface]);
+    /** Controls the block's viewport. You can fullscreen the block and add size
+     * constrains using `viewport`.
+     */
+    (0, _defineProperty2.default)(_this, "viewport", void 0);
+    /** Returns information about the active table, active view, and selected records. */
+    (0, _defineProperty2.default)(_this, "cursor", void 0);
+    /**
+     * Controls the block's {@link settingsButton settings button}.
+     */
+    (0, _defineProperty2.default)(_this, "settingsButton", void 0);
+    /** @hidden */
+    (0, _defineProperty2.default)(_this, "undoRedo", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "performRecordAction", void 0);
+    // When models are updated on the frontend, we want to batch them together and have React do a
+    // single render.
+    //
+    // Without this, in sync-mode React (the current default), anything that triggers an update
+    // (like .setState or .forceUpdate) will instantly, synchronously re-render. So if you have an
+    // update that triggers multiple updates across your tree, you get multiple renders in an
+    // unpredictable order. This is bad because it's unnecessary work and the update order can
+    // contradict react's normal top-down data flow which can cause subtle bugs.
+    //
+    // We set _runWithUpdateBatching to ReactDOM.unstable_batchedUpdates to facilitate this. We
+    // don't know for sure though that React is in use on the page, so we leave actually setting
+    // this when the developer sets up their block with React, in UI.initializeBlock.
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_runWithUpdateBatching", defaultUpdateBatcher);
+    var sdkInitData = airtableInterface.sdkInitData;
+
+    // Bind the public methods on this class so users can import
+    // just the method, e.g.
+    // import {reload} from '@airtable/blocks';
+    _this.unstable_fetchAsync = _this.unstable_fetchAsync.bind(_this);
+    _this.viewport = new _viewport.default(sdkInitData.isFullscreen, airtableInterface);
+    _this.cursor = new _cursor.default(_this);
+    _this.settingsButton = new _settings_button.default(airtableInterface);
+    _this.undoRedo = new _undo_redo.default(airtableInterface);
+    _this.performRecordAction = new _perform_record_action.PerformRecordAction(_this, airtableInterface);
+
+    // Now that we've constructed our models, let's hook them up to realtime changes.
+    _this._registerHandlers();
+
+    // TODO: freeze this object before we ship the code editor.
+    return _this;
+  }
+  /** @internal */
+  (0, _inherits2.default)(BaseBlockSdk, _BlockSdkCore);
+  return (0, _createClass2.default)(BaseBlockSdk, [{
+    key: "_constructSession",
+    value: function _constructSession() {
+      return new _session.default(this);
+    }
+    /** @internal */
+  }, {
+    key: "_constructBase",
+    value: function _constructBase() {
+      return new _base.default(this);
+    }
+    /** @internal */
+  }, {
+    key: "_constructMutations",
+    value: function _constructMutations() {
+      return new _mutations.default(this, this.session, this.base, changes => this.__applyModelChanges(changes), updates => this.__applyGlobalConfigUpdates(updates));
+    }
+    /** @internal */
+  }, {
+    key: "__applyModelChanges",
+    value: function __applyModelChanges(changes) {
+      this._runWithUpdateBatching(() => {
+        var changedBasePaths = this.base.__applyChangesWithoutTriggeringEvents(changes);
+        var changedCursorKeys = this.cursor.__applyChangesWithoutTriggeringEvents(changes);
+        var changedSessionKeys = this.session.__applyChangesWithoutTriggeringEvents(changes);
+        this.base.__triggerOnChangeForChangedPaths(changedBasePaths);
+        this.cursor.__triggerOnChangeForChangedKeys(changedCursorKeys);
+        this.session.__triggerOnChangeForChangedKeys(changedSessionKeys);
+      });
+    }
+    /** @internal */
+  }, {
+    key: "__applyGlobalConfigUpdates",
+    value: function __applyGlobalConfigUpdates(updates) {
+      this._runWithUpdateBatching(() => {
+        this.globalConfig.__setMultipleKvPaths(updates);
+      });
+    }
+    /** @internal */
+  }, {
+    key: "_registerHandlers",
+    value: function _registerHandlers() {
+      // base
+
+      this.__airtableInterface.subscribeToModelUpdates(_ref => {
+        var changes = _ref.changes;
+        this.__applyModelChanges(changes);
+      });
+
+      // global config
+      this.__airtableInterface.subscribeToGlobalConfigUpdates(_ref2 => {
+        var updates = _ref2.updates;
+        this.__applyGlobalConfigUpdates(updates);
+      });
+
+      // settings button
+      this.__airtableInterface.subscribeToSettingsButtonClick(() => {
+        if (this.settingsButton.isVisible) {
+          this._runWithUpdateBatching(() => {
+            // Since there's an async gap when communicating with liveapp,
+            // no-op if the button has been hidden since it was clicked.
+            this.settingsButton.__onClick();
+          });
+        }
+      });
+
+      // viewport
+      this.__airtableInterface.subscribeToEnterFullScreen(() => {
+        this._runWithUpdateBatching(() => {
+          this.viewport.__onEnterFullscreen();
+        });
+      });
+      this.__airtableInterface.subscribeToExitFullScreen(() => {
+        this._runWithUpdateBatching(() => {
+          this.viewport.__onExitFullscreen();
+        });
+      });
+      this.__airtableInterface.subscribeToFocus(() => {
+        this._runWithUpdateBatching(() => {
+          this.viewport.__focus();
+        });
+      });
+    }
+    /** @internal */
+  }, {
+    key: "__setBatchedUpdatesFn",
+    value: function __setBatchedUpdatesFn(newUpdateBatcher) {
+      this._runWithUpdateBatching = newUpdateBatcher;
+    }
+
+    /** @hidden */
+  }, {
+    key: "unstable_fetchAsync",
+    value: (function () {
+      var _unstable_fetchAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(requestJson) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.__airtableInterface.performBackendFetchAsync(requestJson);
+            case 2:
+              return _context.abrupt("return", _context.sent);
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function unstable_fetchAsync(_x) {
+        return _unstable_fetchAsync.apply(this, arguments);
+      }
+      return unstable_fetchAsync;
+    }() /** @hidden */)
+  }, {
+    key: "getBlockRunContext",
+    value: function getBlockRunContext() {
+      return this.__airtableInterface.sdkInitData.runContext;
+    }
+  }]);
+}(_sdk_core.BlockSdkCore);

package/dist/cjs/base/settings_button.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 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 _watchable = _interopRequireDefault(require("../shared/watchable"));
+var _private_utils = require("../shared/private_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: settingsButton */ /** */
+var WatchableSettingsButtonKeys = Object.freeze({
+  isVisible: 'isVisible',
+  click: 'click'
+});
+
+/**
+ * A watchable key in {@link SettingsButton}.
+ * - `isVisible`
+ * - `click`
+ */
+/**
+ * Interface to the settings button that lives outside the extension's viewport.
+ *
+ * The {@link useSettingsButton} hook is the recommended way to use the settings button, but you can
+ * also use it with {@link useWatchable} if you want more granular control (for example, to only
+ * show the button conditionally).
+ *
+ * @alias settingsButton
+ * @example
+ * ```js
+ * import {settingsButton} from '@airtable/blocks';
+ * import {useWatchable} from '@airtable/blocks/ui';
+ *
+ * function AppWithSettings({shouldShowSettingsButton}) {
+ *     useEffect(() => {
+ *         // A count of calls to `show()` and `hide()` is maintained internally. The button will
+ *         // stay visible if there are more calls to `show()` than `hide()` - so here, we check
+ *         // `isVisible` so we only we only call them when necessary.
+ *         // The button is not visible by default.
+ *         if (shouldShowSettingsButton && !settingsButton.isVisible) {
+ *             settingsButton.show();
+ *         } else if (!shouldShowSettingsButton && settingsButton.isVisible) {
+ *             settingsButton.hide();
+ *         }
+ *     });
+ *
+ *     useWatchable(settingsButton, 'click', function() {
+ *         alert('Clicked!');
+ *     });
+ * }
+ * ```
+ * @docsPath models/SettingsButton
+ */
+var SettingsButton = /*#__PURE__*/function (_Watchable) {
+  /** @internal */
+  function SettingsButton(airtableInterface) {
+    var _this;
+    (0, _classCallCheck2.default)(this, SettingsButton);
+    _this = _callSuper(this, SettingsButton);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_refCount", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_airtableInterface", void 0);
+    _this._refCount = 0;
+    _this._airtableInterface = airtableInterface;
+    return _this;
+  }
+
+  /**
+   * Whether the settings button is being shown.
+   * Can be watched.
+   */
+  (0, _inherits2.default)(SettingsButton, _Watchable);
+  return (0, _createClass2.default)(SettingsButton, [{
+    key: "isVisible",
+    get: function get() {
+      return this._refCount > 0;
+    }
+
+    /**
+     * Show the settings button.
+     */
+  }, {
+    key: "show",
+    value: function show() {
+      // Is now visible: trigger change watches and set it to be visible
+      if (this._refCount === 0) {
+        this._onChange(WatchableSettingsButtonKeys.isVisible, true);
+        this._airtableInterface.setSettingsButtonVisibility(true);
+      }
+      this._refCount += 1;
+    }
+
+    /**
+     * Hide the settings button.
+     *
+     * Note: A count of calls to `show()` and `hide()` is maintained internally. The button will
+     * stay visible if there are more calls to `show()` than `hide()`.
+     */
+  }, {
+    key: "hide",
+    value: function hide() {
+      // Be forgiving if hide() is called too many times, since we don't expose the count
+      if (this._refCount > 0) {
+        this._refCount -= 1;
+      }
+
+      // Should no longer be visible: trigger change watches and set it to be not visible
+      if (this._refCount === 0) {
+        this._onChange(WatchableSettingsButtonKeys.isVisible, false);
+        this._airtableInterface.setSettingsButtonVisibility(false);
+      }
+    }
+
+    /** @internal */
+  }, {
+    key: "__onClick",
+    value: function __onClick() {
+      this._onChange(WatchableSettingsButtonKeys.click);
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableSettingsButtonKeys, key);
+    }
+  }]);
+}(_watchable.default);
+/** @internal */
+(0, _defineProperty2.default)(SettingsButton, "_className", 'SettingsButton');
+var _default = exports.default = SettingsButton;

package/dist/cjs/base/types/aggregators.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/base/types/airtable_interface.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockRunContextType = void 0;
+// BlockRunContextType, BlockInstallationPageBlockRunContext, ViewBlockRunContext, BlockRunContext
+// must be kept in sync with block_run_context.tsx in hyperbase repo
+/** @hidden */
+var BlockRunContextType = exports.BlockRunContextType = /*#__PURE__*/function (BlockRunContextType) {
+  BlockRunContextType["DASHBOARD_APP"] = "dashboardApp";
+  BlockRunContextType["VIEW"] = "view";
+  return BlockRunContextType;
+}({});
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+// TODO: (SeanKeenan) Move NormalizedSortConfig from record_query_result here
+//       once/if we support setting the sort config for a view
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/** @hidden */
+/**
+ * AirtableInterface is designed as the communication interface between the
+ * Block SDK and Airtable. The mechanism through which we communicate with Airtable
+ * depends on the context in which the block is running (i.e. frontend or backend),
+ * but the interface should remain consistent.
+ *
+ * @hidden
+ */

package/dist/cjs/base/types/backend_fetch_types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/base/types/base.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/base/types/cursor.js

@@ -0,0 +1 @@
+"use strict";