@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-75d011284-20250904

package/dist/cjs/base/viewport.js

@@ -1,31 +1,16 @@
 "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({
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module @airtable/blocks: viewport */ /** */
+
+const WatchableViewportKeys = Object.freeze({
   isFullscreen: 'isFullscreen',
   size: 'size',
   minSize: 'minSize',
@@ -42,7 +27,7 @@ var WatchableViewportKeys = Object.freeze({
 
 /** */
 
-var compareWithNulls = (a, b, compare) => {
+const compareWithNulls = (a, b, compare) => {
   if (a !== null && b !== null) {
     return compare(a, b);
   }
@@ -66,44 +51,49 @@ var compareWithNulls = (a, b, compare) => {
  * ```
  * @docsPath models/Viewport
  */
-var Viewport = /*#__PURE__*/function (_Watchable) {
+class Viewport extends _watchable.default {
+  /** @internal */
+  static _className = 'Viewport';
+  /** @internal */
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableViewportKeys, key);
+  }
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   /** @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;
+  _minSizes = new Set();
+  /** @internal */
+  _maxFullscreenSizes = new Set();
+  /** @internal */
+  _cachedMaxFullscreenSize = null;
+  /** @internal */
+  _cachedMinSize = null;
+
+  /** @internal */
+  constructor(isFullscreen, airtableInterface) {
+    super();
+    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);
+    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);
+    this.watch(WatchableViewportKeys.maxFullscreenSize, () => {
+      this._airtableInterface.setFullscreenMaxSize(this.maxFullscreenSize);
     });
-    return _this;
   }
   /**
    * Request to enter fullscreen mode.
@@ -112,286 +102,252 @@ var Viewport = /*#__PURE__*/function (_Watchable) {
    * 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();
-    }
+  enterFullscreenIfPossible() {
+    this._airtableInterface.enterFullscreen();
+  }
+  /** Request to exit fullscreen mode */
+  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;
+  /**
+   * 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`.
+   */
+  get maxFullscreenSize() {
+    if (!this._cachedMaxFullscreenSize) {
+      const 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
+      });
+      const 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
-      });
+  /**
+   * 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.
+   */
+  addMaxFullscreenSize(sizeConstraint) {
+    const {
+      width,
+      height
+    } = sizeConstraint;
+    const 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.add(size);
+      this._maxFullscreenSizes.delete(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;
+  /**
+   * 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.
+   */
+  get minSize() {
+    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
-      });
+  /**
+   * 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.
+   */
+  addMinSize(sizeConstraint) {
+    const {
+      width,
+      height
+    } = sizeConstraint;
+    const 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;
-      // min size is also a constraint on maxFullscreenSize:
       this._cachedMaxFullscreenSize = null;
-      this._minSizes.add(size);
+      this._minSizes.delete(size);
       this._onChange(WatchableViewportKeys.minSize);
+      // min size is also a constraint on maxFullscreenSize:
       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);
-        }
+  /**
+   * `true` if the extension frame is smaller than `minSize`, `false` otherwise.
+   */
+  get isSmallerThanMinSize() {
+    const {
+      width,
+      height
+    } = this.size;
+    const isWidthTooSmall = this.minSize.width !== null && this.minSize.width > width;
+    const isHeightTooSmall = this.minSize.height !== null && this.minSize.height > height;
+    return isWidthTooSmall || isHeightTooSmall;
+  }
+  /**
+   * `true` if the extension is fullscreen, `false` otherwise.
+   */
+  get isFullscreen() {
+    return this._isFullscreen;
+  }
+  /**
+   * The current size of the extension frame.
+   *
+   * Can be watched.
+   */
+  get size() {
+    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`.
+   */
+  watch(keys, callback, context) {
+    const validKeys = super.watch(keys, callback, context);
+    if (validKeys.includes(WatchableViewportKeys.size)) {
+      if (this._sizeWatchCount === 0) {
+        window.addEventListener('resize', this._onSizeChangeDebounced, false);
       }
-      return validKeys;
-    }
-    /**
-     * @internal
-     */
-  }, {
-    key: "__onEnterFullscreen",
-    value: function __onEnterFullscreen() {
-      this._isFullscreen = true;
-      this._onChange(WatchableViewportKeys.isFullscreen);
-      this._onChange(WatchableViewportKeys.size);
+      this._sizeWatchCount++;
     }
-    /**
-     * @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();
+    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`
+   */
+  unwatch(keys, callback, context) {
+    const validKeys = super.unwatch(keys, callback, context);
+    if (validKeys.includes(WatchableViewportKeys.size)) {
+      this._sizeWatchCount--;
+      if (this._sizeWatchCount === 0) {
+        window.removeEventListener('resize', this._onSizeChangeDebounced, false);
       }
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "_onSizeChange",
-    value: function _onSizeChange() {
-      this._onChange(WatchableViewportKeys.size);
-    }
-  }], [{
-    key: "_isWatchableKey",
-    value: /** @internal */
-    function _isWatchableKey(key) {
-      return (0, _private_utils.isEnumValue)(WatchableViewportKeys, key);
+    return validKeys;
+  }
+  /**
+   * @internal
+   */
+  __onEnterFullscreen() {
+    this._isFullscreen = true;
+    this._onChange(WatchableViewportKeys.isFullscreen);
+    this._onChange(WatchableViewportKeys.size);
+  }
+  /**
+   * @internal
+   */
+  __onExitFullscreen() {
+    this._isFullscreen = false;
+    this._onChange(WatchableViewportKeys.isFullscreen);
+    this._onChange(WatchableViewportKeys.size);
+  }
+  /**
+   * @internal
+   */
+  __focus() {
+    const {
+      body,
+      activeElement
+    } = document;
+    // 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.
+      const input = document.createElement('input');
+      body.appendChild(input);
+      input.focus();
+      input.remove();
     }
-  }]);
-}(_watchable.default);
-/** @internal */
-(0, _defineProperty2.default)(Viewport, "_className", 'Viewport');
+  }
+  /**
+   * @internal
+   */
+  _onSizeChange() {
+    this._onChange(WatchableViewportKeys.size);
+  }
+}
 var _default = exports.default = Viewport;

package/dist/cjs/injected/airtable_interface.js

@@ -5,13 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 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('');
+const AIRTABLE_INTERFACE_VERSION = 0;
+let airtableInterface = null;
+const 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;
+  const getAirtableInterfaceAtVersion = window.__getAirtableInterfaceAtVersion;
   if (!airtableInterface) {
     if (!getAirtableInterfaceAtVersion) {
       throw (0, _error_utils.spawnError)(missingAirtableInterfaceErrorMessage);