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

package/dist/cjs/shared/watchable.js

@@ -1,29 +1,13 @@
 "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.concat.js");
-require("core-js/modules/es.array.filter.js");
-require("core-js/modules/es.array.iterator.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 _private_utils = require("./private_utils");
 var _error_utils = require("./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; } /** @module @airtable/blocks/models: Abstract models */ /** */
+/** @module @airtable/blocks/models: Abstract models */ /** */
+
 /**
  * Abstract superclass for watchable models. All watchable models expose `watch`
  * and `unwatch` methods that allow consumers to subscribe to changes to that model.
@@ -32,18 +16,24 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  *
  * @docsPath models/advanced/Watchable
  */
-var Watchable = /*#__PURE__*/function () {
+class Watchable {
+  /** @internal */
+  static _className = 'Watchable';
+  /** @internal */
+  static _isWatchableKey(_key) {
+    // Override to return whether `key` is a valid watchable key.
+    return false;
+  }
+  /** @internal */
+  _changeCount = 0;
+  /** @internal */
+  _watchableId = (0, _private_utils.getLocallyUniqueId)();
+  /** @internal */
+
   /**
    * @internal
    */
-  function Watchable() {
-    (0, _classCallCheck2.default)(this, Watchable);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_changeCount", 0);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_watchableId", (0, _private_utils.getLocallyUniqueId)());
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_changeWatchersByKey", void 0);
+  constructor() {
     this._changeWatchersByKey = {};
   }
   // React integrations (e.g. useSubscription) rely on referential equality (===) to determine
@@ -54,163 +44,107 @@ var Watchable = /*#__PURE__*/function () {
   /**
    * @internal
    */
-  return (0, _createClass2.default)(Watchable, [{
-    key: "__getWatchableKey",
-    value: function __getWatchableKey() {
-      return "".concat(this._watchableId, " ").concat(this._changeCount);
-    }
-    /**
-     * Helper method to get only the valid watchable keys - or throw if a key is invalid
-     *
-     * @param keys
-     * @internal
-     */
-  }, {
-    key: "_getWatchableValidKeysOrThrow",
-    value: function _getWatchableValidKeysOrThrow(keys, errorMethodName, shouldWarnInsteadOfThrow) {
-      var arrayKeys = Array.isArray(keys) ? keys : [keys];
-      var validKeys = [];
-      var _iterator = _createForOfIteratorHelper(arrayKeys),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var key = _step.value;
-          if (this.constructor._isWatchableKey(key)) {
-            validKeys.push(key);
-          } else {
-            var className = this.constructor._className;
-            var errorString = "Invalid key to ".concat(errorMethodName, " for ").concat(className, ": ").concat(key);
-            if (shouldWarnInsteadOfThrow) {
-              // eslint-disable-next-line no-console
-              console.warn(errorString);
-            } else {
-              throw (0, _error_utils.spawnError)(errorString);
-            }
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      return validKeys;
-    }
-    /**
-     * Get notified of changes to the model.
-     *
-     * 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 = this._getWatchableValidKeysOrThrow(keys, 'watch');
-      var _iterator2 = _createForOfIteratorHelper(validKeys),
-        _step2;
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var key = _step2.value;
-          if (!this._changeWatchersByKey[key]) {
-            this._changeWatchersByKey[key] = [];
-          }
-          // Rather than pushing onto this array, we initialize a new array.
-          // This is necessary since watches can change as a result of an
-          // event getting triggered. It would be bad if as we iterate over
-          // our watchers, new watchers get pushed onto the array that we
-          // are iterating over.
-          // TODO(jb): as a perf optimization, we *could* push onto this array
-          // as long as we are not in the middle of iterating over it.
-          this._changeWatchersByKey[key] = [...this._changeWatchersByKey[key], {
-            callback,
-            context
-          }];
+  __getWatchableKey() {
+    return `${this._watchableId} ${this._changeCount}`;
+  }
+  /**
+   * Helper method to get only the valid watchable keys - or throw if a key is invalid
+   *
+   * @param keys
+   * @internal
+   */
+  _getWatchableValidKeysOrThrow(keys, errorMethodName, shouldWarnInsteadOfThrow) {
+    const arrayKeys = Array.isArray(keys) ? keys : [keys];
+    const validKeys = [];
+    for (const key of arrayKeys) {
+      if (this.constructor._isWatchableKey(key)) {
+        validKeys.push(key);
+      } else {
+        const className = this.constructor._className;
+        const errorString = `Invalid key to ${errorMethodName} for ${className}: ${key}`;
+        if (shouldWarnInsteadOfThrow) {
+          // eslint-disable-next-line no-console
+          console.warn(errorString);
+        } else {
+          throw (0, _error_utils.spawnError)(errorString);
         }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
       }
-      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 = this._getWatchableValidKeysOrThrow(keys, 'unwatch', true);
-      var _iterator3 = _createForOfIteratorHelper(validKeys),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var key = _step3.value;
-          var watchers = this._changeWatchersByKey[key];
-          if (watchers) {
-            var filteredWatchers = watchers.filter(watcher => {
-              return watcher.callback !== callback || watcher.context !== context;
-            });
-            if (filteredWatchers.length > 0) {
-              this._changeWatchersByKey[key] = filteredWatchers;
-            } else {
-              delete this._changeWatchersByKey[key];
-            }
-          }
-        }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
+    return validKeys;
+  }
+  /**
+   * Get notified of changes to the model.
+   *
+   * 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 = this._getWatchableValidKeysOrThrow(keys, 'watch');
+    for (const key of validKeys) {
+      if (!this._changeWatchersByKey[key]) {
+        this._changeWatchersByKey[key] = [];
       }
-      return validKeys;
+      // Rather than pushing onto this array, we initialize a new array.
+      // This is necessary since watches can change as a result of an
+      // event getting triggered. It would be bad if as we iterate over
+      // our watchers, new watchers get pushed onto the array that we
+      // are iterating over.
+      // TODO(jb): as a perf optimization, we *could* push onto this array
+      // as long as we are not in the middle of iterating over it.
+      this._changeWatchersByKey[key] = [...this._changeWatchersByKey[key], {
+        callback,
+        context
+      }];
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "_onChange",
-    value: function _onChange(key) {
-      this._changeCount += 1;
-      var watchers = this._changeWatchersByKey[key];
+    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 = this._getWatchableValidKeysOrThrow(keys, 'unwatch', true);
+    for (const key of validKeys) {
+      const watchers = this._changeWatchersByKey[key];
       if (watchers) {
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
-          args[_key2 - 1] = arguments[_key2];
-        }
-        var _iterator4 = _createForOfIteratorHelper(watchers),
-          _step4;
-        try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            var watcher = _step4.value;
-            watcher.callback.call(watcher.context, this, key, ...args);
-          }
-        } catch (err) {
-          _iterator4.e(err);
-        } finally {
-          _iterator4.f();
+        const filteredWatchers = watchers.filter(watcher => {
+          return watcher.callback !== callback || watcher.context !== context;
+        });
+        if (filteredWatchers.length > 0) {
+          this._changeWatchersByKey[key] = filteredWatchers;
+        } else {
+          delete this._changeWatchersByKey[key];
         }
       }
     }
-  }], [{
-    key: "_isWatchableKey",
-    value: /** @internal */
-    function _isWatchableKey(_key) {
-      // Override to return whether `key` is a valid watchable key.
-      return false;
+    return validKeys;
+  }
+  /**
+   * @internal
+   */
+  _onChange(key) {
+    this._changeCount += 1;
+    const watchers = this._changeWatchersByKey[key];
+    if (watchers) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      for (const watcher of watchers) {
+        watcher.callback.call(watcher.context, this, key, ...args);
+      }
     }
-  }]);
-}();
-/** @internal */
-(0, _defineProperty2.default)(Watchable, "_className", 'Watchable');
+  }
+}
 var _default = exports.default = Watchable;

package/dist/cjs/stats/block_stats.js

@@ -1,96 +1,73 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.blockStats = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _airtable_interface = _interopRequireDefault(require("../injected/airtable_interface"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // NOTE(richsinn): this client is effectively an implementation of the StatsClient interface
 // for Datadog. For example, see https://github.com/Hyperbase/hyperbase/blob/development/client_server_shared/stats/stats_client.tsx
+
 /** @hidden */
-var BlockStats = /*#__PURE__*/function () {
-  function BlockStats() {
-    (0, _classCallCheck2.default)(this, BlockStats);
+class BlockStats {
+  increment(stat, tags) {
+    this.incrementBy(stat, 1, tags);
+  }
+  incrementBy(stat, value, tags) {
+    (0, _airtable_interface.default)().sendStat({
+      metricType: 'incrementBy',
+      stat,
+      value,
+      tags
+    });
+  }
+  decrement(stat, tags) {
+    this.decrementBy(stat, 1, tags);
+  }
+  decrementBy(stat, value, tags) {
+    (0, _airtable_interface.default)().sendStat({
+      metricType: 'decrementBy',
+      stat,
+      value,
+      tags
+    });
+  }
+  gauge(stat, value, tags) {
+    (0, _airtable_interface.default)().sendStat({
+      metricType: 'gauge',
+      stat,
+      value,
+      tags
+    });
+  }
+  histogram(stat, value, tags) {
+    (0, _airtable_interface.default)().sendStat({
+      metricType: 'histogram',
+      stat,
+      value,
+      tags
+    });
+  }
+  distribution(stat, value, tags) {
+    (0, _airtable_interface.default)().sendStat({
+      metricType: 'distribution',
+      stat,
+      value,
+      tags
+    });
+  }
+  timing(stat, time, tags) {
+    (0, _airtable_interface.default)().sendStat({
+      metricType: 'timing',
+      stat,
+      value: time,
+      tags
+    });
+  }
+  timingWithSum(stat, time, tags) {
+    this.timing(stat, time, tags);
+    this.incrementBy(stat + '.sum', time, tags);
   }
-  return (0, _createClass2.default)(BlockStats, [{
-    key: "increment",
-    value: function increment(stat, tags) {
-      this.incrementBy(stat, 1, tags);
-    }
-  }, {
-    key: "incrementBy",
-    value: function incrementBy(stat, value, tags) {
-      (0, _airtable_interface.default)().sendStat({
-        metricType: 'incrementBy',
-        stat,
-        value,
-        tags
-      });
-    }
-  }, {
-    key: "decrement",
-    value: function decrement(stat, tags) {
-      this.decrementBy(stat, 1, tags);
-    }
-  }, {
-    key: "decrementBy",
-    value: function decrementBy(stat, value, tags) {
-      (0, _airtable_interface.default)().sendStat({
-        metricType: 'decrementBy',
-        stat,
-        value,
-        tags
-      });
-    }
-  }, {
-    key: "gauge",
-    value: function gauge(stat, value, tags) {
-      (0, _airtable_interface.default)().sendStat({
-        metricType: 'gauge',
-        stat,
-        value,
-        tags
-      });
-    }
-  }, {
-    key: "histogram",
-    value: function histogram(stat, value, tags) {
-      (0, _airtable_interface.default)().sendStat({
-        metricType: 'histogram',
-        stat,
-        value,
-        tags
-      });
-    }
-  }, {
-    key: "distribution",
-    value: function distribution(stat, value, tags) {
-      (0, _airtable_interface.default)().sendStat({
-        metricType: 'distribution',
-        stat,
-        value,
-        tags
-      });
-    }
-  }, {
-    key: "timing",
-    value: function timing(stat, time, tags) {
-      (0, _airtable_interface.default)().sendStat({
-        metricType: 'timing',
-        stat,
-        value: time,
-        tags
-      });
-    }
-  }, {
-    key: "timingWithSum",
-    value: function timingWithSum(stat, time, tags) {
-      this.timing(stat, time, tags);
-      this.incrementBy(stat + '.sum', time, tags);
-    }
-  }]);
-}();
-var blockStats = exports.blockStats = new BlockStats();
+}
+const blockStats = exports.blockStats = new BlockStats();

package/dist/cjs/testing/base/abstract_mock_airtable_interface.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractMockAirtableInterface = void 0;
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+// istanbul ignore file
+
+const EventEmitter = require('events');
+
+/** @internal */
+const aggregators = {
+  aggregate(appInterface, summaryFunctionKey, cellValues, fieldData) {
+    return null;
+  },
+  aggregateToString(appInterface, summaryFunctionKey, cellValues, fieldData) {
+    return '';
+  },
+  getAggregatorConfig(summaryFunctionKey) {
+    return {
+      key: '',
+      displayName: '',
+      shortDisplayName: ''
+    };
+  },
+  getAllAvailableAggregatorKeys() {
+    return [];
+  },
+  getAvailableAggregatorKeysForField(fieldData) {
+    return [];
+  }
+};
+
+/** @internal */
+const fieldTypeProvider = {
+  isComputed(fieldData) {
+    return false;
+  },
+  validateConfigForUpdate: () => {
+    return {
+      isValid: true
+    };
+  },
+  getConfig: (appInterface, fieldData, fieldNamesById) => {
+    return {
+      type: fieldData.type,
+      options: fieldData.typeOptions
+    };
+  },
+  canBePrimary: () => {
+    return true;
+  },
+  convertStringToCellValue(appInterface, string, fieldData) {
+    return '';
+  },
+  convertCellValueToString(appInterface, cellValue, fieldData) {
+    return '';
+  },
+  getCellRendererData(appInterface, cellValue, fieldData, shouldWrap) {
+    return {
+      cellValueHtml: `<pre>${JSON.stringify(cellValue)}</pre>`,
+      attributes: {}
+    };
+  },
+  validateCellValueForUpdate(appInterface, newCellValue, currentCellValue, fieldData) {
+    return {
+      isValid: true
+    };
+  },
+  getUiConfig(appInterface, fieldData) {
+    return {
+      iconName: '',
+      desiredCellWidthForRecordCard: 0,
+      minimumCellWidthForRecordCard: 0
+    };
+  }
+};
+
+/** @internal */
+const urlConstructor = {
+  getTableUrl(tableId) {
+    return `https://airtable.test/${tableId}`;
+  },
+  getViewUrl(viewId, tableId) {
+    return `https://airtable.test/${tableId}/${viewId}`;
+  },
+  getRecordUrl(recordId, tableId) {
+    return `https://airtable.test/${tableId}/${recordId}`;
+  },
+  getAttachmentClientUrl(appInterface, attachmentId, attachmentUrl) {
+    return attachmentUrl;
+  }
+};
+
+/** @internal */
+const globalConfigHelpers = {
+  validatePath(path, store) {
+    return {
+      isValid: true
+    };
+  },
+  validateAndApplyUpdates(updates, store) {
+    throw (0, _error_utils.spawnError)('validateAndApplyUpdates unimplemented');
+  }
+};
+
+/** @internal */
+const idGenerator = {
+  generateRecordId: () => 'recGeneratedMockId',
+  generateFieldId: () => 'fldGeneratedMockId',
+  generateTableId: () => 'tblGeneratedMockId'
+};
+
+/**
+ * An abstract base class with a common interface exposed to both Blocks SDK's
+ * internal automated test suite and the blocks-testing public repo.
+ *
+ * @hidden
+ */
+class AbstractMockAirtableInterface extends EventEmitter {
+  constructor(initData) {
+    super();
+    this._initData = (0, _private_utils.cloneDeep)(initData);
+    this.reset();
+  }
+
+  /**
+   * Revert the mock interface to its initial state. This includes:
+   *
+   * - removing all event listeners
+   * - restoring the database schema
+   */
+  reset() {
+    this.removeAllListeners();
+    this.sdkInitData = (0, _private_utils.cloneDeep)(this._initData);
+  }
+
+  // The following properties are defined using accessors in order to
+  // facilitate overriding in subclasses.
+  get aggregators() {
+    return aggregators;
+  }
+  get fieldTypeProvider() {
+    return fieldTypeProvider;
+  }
+  get urlConstructor() {
+    return urlConstructor;
+  }
+  get globalConfigHelpers() {
+    return globalConfigHelpers;
+  }
+  get idGenerator() {
+    return idGenerator;
+  }
+  assertAllowedSdkPackageVersion() {}
+  applyMutationAsync(mutation, opts) {
+    return Promise.resolve();
+  }
+  checkPermissionsForMutation(mutation) {
+    return {
+      hasPermission: true
+    };
+  }
+  createVisList(appInterface, recordDatas, fieldDatas, sorts) {
+    return {
+      removeRecordIds(recordIds) {},
+      addRecordData(recordData) {},
+      getOrderedRecordIds() {
+        return recordDatas.map(_ref => {
+          let {
+            id
+          } = _ref;
+          return id;
+        });
+      }
+    };
+  }
+  subscribeToModelUpdates(fn) {
+    this.on('modelupdates', fn);
+  }
+  setActiveViewOrTable(tableId, viewId) {}
+
+  // TODO(jugglinmike): Implement
+  subscribeToGlobalConfigUpdates() {}
+  subscribeToSettingsButtonClick() {}
+  subscribeToEnterFullScreen() {}
+  subscribeToExitFullScreen() {}
+  subscribeToFocus() {}
+  triggerModelUpdates(changes) {
+    this.emit('modelupdates', {
+      changes
+    });
+  }
+
+  // TODO(jugglinmike): Implement
+  triggerGlobalConfigUpdates() {}
+  triggerSettingsButtonClick() {}
+  triggerEnterFullScreen() {}
+  triggerExitFullScreen() {}
+  triggerFocus() {}
+  unsubscribeFromCursorData() {}
+  unsubscribeFromTableData() {}
+  unsubscribeFromCellValuesInFields() {}
+  unsubscribeFromViewData() {}
+}
+exports.AbstractMockAirtableInterface = AbstractMockAirtableInterface;