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

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

@@ -0,0 +1,306 @@
+"use strict";
+
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.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/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.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"));
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.array.map.js");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _base_core = require("../../shared/models/base_core");
+var _mutations = require("../types/mutations");
+var _private_utils = require("../../shared/private_utils");
+var _record_store = _interopRequireDefault(require("./record_store"));
+var _table = _interopRequireDefault(require("./table"));
+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; }
+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; }
+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/models: Base */ /** */
+/**
+ * Model class representing a base.
+ *
+ * If you want the base model to automatically recalculate whenever the base schema changes, try the
+ * {@link useBase} hook. Alternatively, you can manually subscribe to changes with
+ * {@link useWatchable} (recommended) or [Base#watch](/api/models/Base#watch).
+ *
+ * @example
+ * ```js
+ * import {base} from '@airtable/blocks';
+ *
+ * console.log('The name of your base is', base.name);
+ * ```
+ * @docsPath models/Base
+ */
+var 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.default(this, recordStore, tableId, this._sdk);
+    }
+
+    /** @internal */
+  }, {
+    key: "_constructRecordStore",
+    value: function _constructRecordStore(sdk, tableId) {
+      return new _record_store.default(sdk, tableId);
+    }
+
+    /** @internal */
+  }, {
+    key: "_iterateTableIds",
+    value: function _iterateTableIds() {
+      return this._data.tableOrder;
+    }
+
+    /**
+     * Checks whether the current user has permission to create a table.
+     *
+     * Accepts partial input, in the same format as {@link createTableAsync}.
+     *
+     * Returns `{hasPermission: true}` if the current user can update the specified record,
+     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+     * used to display an error message to the user.
+     *
+     * @param name name for the table. must be case-insensitive unique
+     * @param fields array of fields to create in the table
+     *
+     * @example
+     * ```js
+     * const createTableCheckResult = base.checkPermissionsForCreateTable();
+     *
+     * if (!createTableCheckResult.hasPermission) {
+     *     alert(createTableCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+  }, {
+    key: "checkPermissionsForCreateTable",
+    value: function checkPermissionsForCreateTable(name, fields) {
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.CREATE_SINGLE_TABLE,
+        id: undefined,
+        // Generated in createTableAsync.
+        name: name,
+        fields: fields === null || fields === void 0 ? void 0 : fields.map(field => {
+          return {
+            name: field.name,
+            config: field.type ? _objectSpread({
+              type: field.type
+            }, field.options ? {
+              options: field.options
+            } : null) : undefined,
+            description: field.description
+          };
+        })
+      });
+    }
+
+    /**
+     * An alias for `checkPermissionsForCreateTable(name, fields).hasPermission`.
+     *
+     * Checks whether the current user has permission to create a table.
+     *
+     * Accepts partial input, in the same format as {@link createTableAsync}.
+     *
+     * @param name name for the table. must be case-insensitive unique
+     * @param fields array of fields to create in the table
+     *
+     * @example
+     * ```js
+     * const canCreateTable = table.hasPermissionToCreateTable();
+     *
+     * if (!canCreateTable) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+  }, {
+    key: "hasPermissionToCreateTable",
+    value: function hasPermissionToCreateTable(name, fields) {
+      return this.checkPermissionsForCreateTable(name, fields).hasPermission;
+    }
+
+    /**
+     * Creates a new table.
+     *
+     * Throws an error if the user does not have permission to create a table, if an invalid
+     * table name is provided, or if invalid fields are provided (invalid name, type, options or
+     * description).
+     *
+     * Refer to {@link FieldType} for supported field types, the write format for field options, and
+     * other specifics for certain field types.
+     *
+     * At least one field must be specified. The first field in the `fields` array will be used as
+     * the table's [primary field](https://support.airtable.com/hc/en-us/articles/202624179-The-Name-Field)
+     * and must be a supported primary field type. Fields must have case-insensitive unique names
+     * within the table.
+     *
+     * A default grid view will be created with all fields visible.
+     *
+     * This action is asynchronous. Unlike new records, new tables are **not** created
+     * optimistically locally. You must `await` the returned promise before using the new
+     * table in your extension.
+     *
+     * @param name name for the table. must be case-insensitive unique
+     * @param fields array of fields to create in the table: see below for an example. `name` and
+     * `type` must be specified for all fields, while `options` is only required for fields that
+     * have field options. `description` is optional and will be `''` if not specified or if
+     * specified as `null`.
+     *
+     * @example
+     * ```js
+     * async function createNewTable() {
+     *     const name = 'My new table';
+     *     const fields = [
+     *         // Name will be the primary field of the table.
+     *         {name: 'Name', type: FieldType.SINGLE_LINE_TEXT, description: 'This is the primary field'},
+     *         {name: 'Notes', type: FieldType.RICH_TEXT},
+     *         {name: 'Attachments', type: FieldType.MULTIPLE_ATTACHMENTS},
+     *         {name: 'Number', type: FieldType.NUMBER, options: {
+     *             precision: 8,
+     *         }},
+     *         {name: 'Select', type: FieldType.SINGLE_SELECT, options: {
+     *             choices: [
+     *                 {name: 'A'},
+     *                 {name: 'B'},
+     *             ],
+     *         }},
+     *     ];
+     *
+     *     if (base.hasPermissionToCreateTable(name, fields)) {
+     *         await base.createTableAsync(name, fields);
+     *     }
+     * }
+     * ```
+     */
+  }, {
+    key: "createTableAsync",
+    value: (function () {
+      var _createTableAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(name, fields) {
+        var tableId;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              tableId = this._sdk.__airtableInterface.idGenerator.generateTableId();
+              _context.next = 3;
+              return this._sdk.__mutations.applyMutationAsync({
+                id: tableId,
+                type: _mutations.MutationTypes.CREATE_SINGLE_TABLE,
+                name,
+                fields: fields.map(field => {
+                  var _field$description;
+                  return {
+                    name: field.name,
+                    config: _objectSpread({
+                      type: field.type
+                    }, field.options ? {
+                      options: field.options
+                    } : null),
+                    // Coerce undefined to null so that only old SDKs pass "undefined" for description
+                    // '' is permitted, as we already set empty descriptions to '' when editing descriptions
+                    // from the UI
+                    description: (_field$description = field.description) !== null && _field$description !== void 0 ? _field$description : null
+                  };
+                })
+              });
+            case 3:
+              return _context.abrupt("return", this.getTableById(tableId));
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function createTableAsync(_x, _x2) {
+        return _createTableAsync.apply(this, arguments);
+      }
+      return createTableAsync;
+    }()
+    /**
+     * @internal
+     */
+    )
+  }, {
+    key: "__triggerOnChangeForChangedPaths",
+    value: function __triggerOnChangeForChangedPaths(changedPaths) {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(Base.prototype), "__triggerOnChangeForChangedPaths", this).call(this, changedPaths);
+      var didSchemaChange = false;
+      if (changedPaths.tableOrder) {
+        this._onChange(_base_core.WatchableBaseKeys.tables);
+        didSchemaChange = true;
+
+        // Clean up deleted tables
+        var _iterator = _createForOfIteratorHelper((0, _private_utils.entries)(this._tableModelsById)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+              tableId = _step$value[0],
+              tableModel = _step$value[1];
+            if (tableModel.isDeleted) {
+              delete this._tableModelsById[tableId];
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        var _iterator2 = _createForOfIteratorHelper((0, _private_utils.entries)(this._tableRecordStoresByTableId)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
+              _tableId = _step2$value[0],
+              recordStore = _step2$value[1];
+            if (recordStore && recordStore.isDeleted) {
+              recordStore.__onDataDeletion();
+              delete this._tableRecordStoresByTableId[_tableId];
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+      if (didSchemaChange) {
+        this._onChange(_base_core.WatchableBaseKeys.schema);
+      }
+    }
+  }]);
+}(_base_core.BaseCore);
+/** @internal */
+(0, _defineProperty2.default)(Base, "_className", 'Base');
+var _default = exports.default = Base;

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

@@ -0,0 +1,115 @@
+"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.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.__injectSdkIntoCreateAggregators = __injectSdkIntoCreateAggregators;
+exports.default = createAggregators;
+require("core-js/modules/es.array.map.js");
+var _error_utils = require("../../shared/error_utils");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } // istanbul ignore file
+/** @module @airtable/blocks/models: Aggregators */ /** */
+/**
+ * Aggregators can be used to compute aggregates for cell values.
+ *
+ * @example
+ * ```js
+ * import {aggregators} from '@airtable/blocks/models';
+ *
+ * // To get a list of aggregators supported for a specific field:
+ * const fieldAggregators = myField.availableAggregators;
+ *
+ * // To compute the total attachment size of an attachment field:
+ * const aggregator = aggregators.totalAttachmentSize;
+ * const value = aggregator.aggregate(myRecords, myAttachmentField);
+ * const valueAsString = aggregate.aggregateToString(myRecords, myAttachmentField);
+ * ```
+ * @docsPath models/Aggregator
+ */
+
+/**
+ * Note: this is hidden instead of internal as it is the type of the public models.aggregators.
+ *
+ * If its internal, typescript won't know about it since the types will be stripped, and typescript
+ * blocks will error due to incomplete type definitions.
+ *
+ * @hidden
+ */
+
+var aggregate = (aggregatorKey, records, field) => {
+  if (!field.isAggregatorAvailable(aggregatorKey)) {
+    throw (0, _error_utils.spawnError)('The %s aggregator is not available for %s fields', aggregatorKey, field.type);
+  }
+  var _sdk2 = sdk,
+    appInterface = _sdk2.__appInterface,
+    airtableInterface = _sdk2.__airtableInterface;
+  var cellValues = records.map(record => record._getRawCellValue(field));
+  return airtableInterface.aggregators.aggregate(appInterface, aggregatorKey, cellValues, field._data);
+};
+var aggregateToString = (aggregatorKey, records, field) => {
+  if (!field.isAggregatorAvailable(aggregatorKey)) {
+    throw (0, _error_utils.spawnError)('The %s aggregator is not available for %s fields', aggregatorKey, field.type);
+  }
+  var _sdk3 = sdk,
+    appInterface = _sdk3.__appInterface,
+    airtableInterface = _sdk3.__airtableInterface;
+  var cellValues = records.map(record => record._getRawCellValue(field));
+  return airtableInterface.aggregators.aggregateToString(appInterface, aggregatorKey, cellValues, field._data);
+};
+
+/**
+ * Note: this is hidden instead of internal as it is used to determine the type of the public
+ * models.aggregators.
+ *
+ * If its internal, typescript won't know about it since the types will be stripped, and typescript
+ * blocks will error due to incomplete type definitions.
+ *
+ * TODO: this should be made less brittle.
+ *
+ * @hidden
+ */
+function createAggregators() {
+  var _sdk4 = sdk,
+    airtableInterface = _sdk4.__airtableInterface;
+  var aggregators = {};
+  var aggregatorKeys = airtableInterface.aggregators.getAllAvailableAggregatorKeys();
+  var _iterator = _createForOfIteratorHelper(aggregatorKeys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _key = _step.value;
+      var config = airtableInterface.aggregators.getAggregatorConfig(_key);
+      aggregators[_key] = Object.freeze({
+        key: _key,
+        displayName: config.displayName,
+        shortDisplayName: config.shortDisplayName,
+        aggregate: aggregate.bind(null, _key),
+        aggregateToString: aggregateToString.bind(null, _key)
+      });
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  Object.freeze(aggregators);
+  return aggregators;
+}
+var sdk;
+
+// The application-level Sdk instance must be injected dynamically to avoid
+// circular dependencies at the time of module resolution.
+function __injectSdkIntoCreateAggregators(_sdk) {
+  sdk = _sdk;
+}