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

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

@@ -0,0 +1,431 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.iterator.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.weak-map.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"));
+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 _private_utils = require("../../shared/private_utils");
+var _mutations = require("../types/mutations");
+var _abstract_model = _interopRequireDefault(require("../../shared/models/abstract_model"));
+var _object_pool = _interopRequireDefault(require("./object_pool"));
+var _record_query_result = _interopRequireWildcard(require("./record_query_result"));
+var _view_metadata_query_result = _interopRequireDefault(require("./view_metadata_query_result"));
+var RecordColoring = _interopRequireWildcard(require("./record_coloring"));
+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 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: View */ /** */
+// This doesn't follow our enum naming conventions because we want the keys
+// to mirror the method/getter names on the model class.
+var WatchableViewKeys = Object.freeze({
+  name: 'name',
+  isLockedView: 'isLockedView'
+});
+
+/**
+ * A key in {@link View} that can be watched.
+ * - `name`
+ */
+/**
+ * A class that represents an Airtable view. Every {@link Table} has one or more views.
+ *
+ * @docsPath models/View
+ */
+var View = /*#__PURE__*/function (_AbstractModel) {
+  /**
+   * @internal
+   */
+  function View(sdk, parentTable, viewDataStore, viewId) {
+    var _this;
+    (0, _classCallCheck2.default)(this, View);
+    _this = _callSuper(this, View, [sdk, viewId]);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_parentTable", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "_viewDataStore", void 0);
+    /** @internal */
+    (0, _defineProperty2.default)(_this, "__viewMetadataQueryResultPool", void 0);
+    _this._parentTable = parentTable;
+    _this._viewDataStore = viewDataStore;
+    _this.__viewMetadataQueryResultPool = new _object_pool.default(_view_metadata_query_result.default);
+    return _this;
+  }
+
+  /**
+   * @internal
+   */
+  (0, _inherits2.default)(View, _AbstractModel);
+  return (0, _createClass2.default)(View, [{
+    key: "_dataOrNullIfDeleted",
+    get: function get() {
+      var _tableData$viewsById$;
+      var tableData = this._baseData.tablesById[this.parentTable.id];
+      return (_tableData$viewsById$ = tableData === null || tableData === void 0 ? void 0 : tableData.viewsById[this._id]) !== null && _tableData$viewsById$ !== void 0 ? _tableData$viewsById$ : null;
+    }
+    /**
+     * The table that this view belongs to. Should never change because views aren't moved between tables.
+     *
+     * @internal (since we may not be able to return parent model instances in the immutable models world)
+     * @example
+     * ```js
+     * const view = myTable.getViewByName('Grid View');
+     * console.log(view.parentTable.id === myTable.id);
+     * // => true
+     * ```
+     */
+  }, {
+    key: "parentTable",
+    get: function get() {
+      return this._parentTable;
+    }
+    /**
+     * The name of the view. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myView.name);
+     * // => 'Grid view'
+     * ```
+     */
+  }, {
+    key: "name",
+    get: function get() {
+      return this._data.name;
+    }
+    /**
+     * The type of the view, such as Grid, Calendar, or Kanban. Should never change because view types cannot be modified.
+     *
+     * @example
+     * ```js
+     * console.log(myView.type);
+     * // => 'kanban'
+     * ```
+     */
+  }, {
+    key: "type",
+    get: function get() {
+      return this._data.type;
+    }
+    /**
+     * If the view is locked. Can be watched.
+     *
+     * @example
+     * ```js
+     * console.log(myView.isLockedView);
+     * // => false
+     * ```
+     */
+  }, {
+    key: "isLockedView",
+    get: function get() {
+      return this._data.isLockedView;
+    }
+    /**
+     * The URL for the view. You can visit this URL in the browser to be taken to the view in the Airtable UI.
+     *
+     * @example
+     * ```js
+     * console.log(myView.url);
+     * // => 'https://airtable.com/appxxxxxxxxxxxxxx/tblxxxxxxxxxxxxxx/viwxxxxxxxxxxxxxx'
+     * ```
+     */
+  }, {
+    key: "url",
+    get: function get() {
+      return this._sdk.__airtableInterface.urlConstructor.getViewUrl(this.id, this.parentTable.id);
+    }
+    /**
+     * Select records from the view. Returns a {@link RecordQueryResult}.
+     *
+     * Consider using {@link useRecords} or {@link useRecordIds} instead, unless you need the
+     * features of a QueryResult (e.g. `queryResult.getRecordById`). Record hooks handle
+     * loading/unloading and updating your UI automatically, but manually `select`ing records is
+     * useful for one-off data processing.
+     *
+     * @param opts Options for the query, such as sorts, fields, and record coloring. By
+     * default, records will be coloured according to the view.
+     * @example
+     * ```js
+     * import {useBase, useRecords} from '@airtable/blocks/UI';
+     * import React from 'react';
+     *
+     * function TodoList() {
+     *     const base = useBase();
+     *     const table = base.getTableByName('Tasks');
+     *     const view = table.getViewByName('Grid view');
+     *
+     *     const queryResult = view.selectRecords();
+     *     const records = useRecords(queryResult);
+     *
+     *     return (
+     *         <ul>
+     *             {records.map(record => (
+     *                 <li key={record.id}>
+     *                     {record.name || 'Unnamed record'}
+     *                 </li>
+     *             ))}
+     *         </ul>
+     *     );
+     * }
+     * ```
+     */
+  }, {
+    key: "selectRecords",
+    value: function selectRecords() {
+      var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var normalizedOpts = _record_query_result.default._normalizeOpts(this.parentTable, this._viewDataStore.parentRecordStore, _objectSpread(_objectSpread({}, opts), {}, {
+        recordColorMode: opts.recordColorMode === undefined ? RecordColoring.modes.byView(this) : opts.recordColorMode
+      }));
+      return this.parentTable.__tableOrViewQueryResultPool.getObjectForReuse(this._sdk, this, normalizedOpts);
+    }
+    /**
+     * Select and load records from the view. Returns a {@link RecordQueryResult} promise where
+     * record data has been loaded.
+     *
+     * Consider using {@link useRecords} or {@link useRecordIds} instead, unless you need the
+     * features of a QueryResult (e.g. `queryResult.getRecordById`). Record hooks handle
+     * loading/unloading and updating your UI automatically, but manually `select`ing records is
+     * useful for one-off data processing.
+     *
+     * Once you've finished with your query, remember to call `queryResult.unloadData()`.
+     *
+     * @param opts Options for the query, such as sorts, fields, and record coloring. By
+     * default, records will be coloured according to the view.
+     * @example
+     * ```js
+     * async function getRecordCountAsync(view) {
+     *     const query = await view.selectRecordsAsync();
+     *     const recordCount = query.recordIds.length;
+     *     query.unloadData();
+     *     return recordCount;
+     * }
+     * ```
+     */
+  }, {
+    key: "selectRecordsAsync",
+    value: (function () {
+      var _selectRecordsAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var opts,
+          queryResult,
+          _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              opts = _args.length > 0 && _args[0] !== undefined ? _args[0] : {};
+              queryResult = this.selectRecords(opts);
+              _context.next = 4;
+              return queryResult.loadDataAsync();
+            case 4:
+              return _context.abrupt("return", queryResult);
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function selectRecordsAsync() {
+        return _selectRecordsAsync.apply(this, arguments);
+      }
+      return selectRecordsAsync;
+    }()
+    /**
+     * Select the field order and visible fields from the view. Returns a
+     * {@link ViewMetadataQueryResult}.
+     *
+     * Consider using {@link useViewMetadata} instead if you're creating a React UI. The
+     * {@link useViewMetadata} hook handles loading/unloading and updating your UI automatically,
+     * but manually `select`ing data is useful for one-off data processing.
+     *
+     * @example
+     * ```js
+     * async function loadMetadataForViewAsync(view) {
+     *     const viewMetadata = view.selectMetadata();
+     *     await viewMetadata.loadDataAsync();
+     *
+     *     console.log('Visible fields:');
+     *     console.log(viewMetadata.visibleFields.map(field => field.name));
+     *     // => ['Field 1', 'Field 2', 'Field 3']
+     *
+     *     console.log('All fields:');
+     *     console.log(viewMetadata.allFields.map(field => field.name));
+     *     // => ['Field 1', 'Field 2', 'Field 3', 'Hidden field 4']
+     *
+     *     viewMetadata.unloadData();
+     * }
+     * ```
+     */
+    )
+  }, {
+    key: "selectMetadata",
+    value: function selectMetadata() {
+      return this.__viewMetadataQueryResultPool.getObjectForReuse(this._sdk, this, this._viewDataStore);
+    }
+    /**
+     * Select and load the field order and visible fields from the view. Returns a
+     * {@link ViewMetadataQueryResult} promise where the metadata has already been loaded.
+     *
+     * Consider using {@link useViewMetadata} instead if you're creating a React UI. The
+     * {@link useViewMetadata} hook handles loading/unloading and updating your UI automatically,
+     * but manually `select`ing data is useful for one-off data processing.
+     *
+     * @example
+     * ```js
+     * async function loadMetadataForViewAsync(view) {
+     *     const viewMetadata = await view.selectMetadata();
+     *
+     *     console.log('Visible fields:');
+     *     console.log(viewMetadata.visibleFields.map(field => field.name));
+     *     // => ['Field 1', 'Field 2', 'Field 3']
+     *
+     *     console.log('All fields:');
+     *     console.log(viewMetadata.allFields.map(field => field.name));
+     *     // => ['Field 1', 'Field 2', 'Field 3', 'Hidden field 4']
+     *
+     *     viewMetadata.unloadData();
+     * }
+     * ```
+     */
+  }, {
+    key: "selectMetadataAsync",
+    value: (function () {
+      var _selectMetadataAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var queryResult;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              queryResult = this.selectMetadata();
+              _context2.next = 3;
+              return queryResult.loadDataAsync();
+            case 3:
+              return _context2.abrupt("return", queryResult);
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function selectMetadataAsync() {
+        return _selectMetadataAsync.apply(this, arguments);
+      }
+      return selectMetadataAsync;
+    }()
+    /**
+     * Checks whether the current user has permission to update view metadata.
+     *
+     * @param viewMetadata
+     * @hidden
+     */
+    )
+  }, {
+    key: "checkPermissionsForUpdateMetadata",
+    value: function checkPermissionsForUpdateMetadata(viewMetadata) {
+      var metadata = {
+        groupLevels: (0, _record_query_result.normalizeSortsOrGroups)(this.parentTable, viewMetadata.groupLevels)
+      };
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.UPDATE_VIEW_METADATA,
+        tableId: this.parentTable.id,
+        viewId: this.id,
+        metadata
+      });
+    }
+
+    /**
+     * An alias for `checkPermissionsForUpdateMetadata(viewMetadata).hasPermission`.
+     *
+     * Checks whether the current user has permission to update view metadata.
+     *
+     * @param viewMetadata
+     * @hidden
+     */
+  }, {
+    key: "hasPermissionToUpdateMetadata",
+    value: function hasPermissionToUpdateMetadata(viewMetadata) {
+      return this.checkPermissionsForUpdateMetadata(viewMetadata).hasPermission;
+    }
+
+    /**
+     * Updates view metadata, this is currently only supported from block views
+     * altering their own view's grouping config.
+     *
+     * @param ViewMetadataForUpdate
+     * @hidden
+     */
+  }, {
+    key: "updateMetadataAsync",
+    value: (function () {
+      var _updateMetadataAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(viewMetadata) {
+        var metadata;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              metadata = {
+                groupLevels: (0, _record_query_result.normalizeSortsOrGroups)(this.parentTable, viewMetadata.groupLevels)
+              };
+              _context3.next = 3;
+              return this._sdk.__mutations.applyMutationAsync({
+                type: _mutations.MutationTypes.UPDATE_VIEW_METADATA,
+                tableId: this.parentTable.id,
+                viewId: this.id,
+                metadata
+              });
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function updateMetadataAsync(_x) {
+        return _updateMetadataAsync.apply(this, arguments);
+      }
+      return updateMetadataAsync;
+    }()
+    /**
+     * @internal
+     */
+    )
+  }, {
+    key: "__triggerOnChangeForDirtyPaths",
+    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      var didViewSchemaChange = false;
+      this._viewDataStore.triggerOnChangeForDirtyPaths(dirtyPaths);
+      if (dirtyPaths.name) {
+        this._onChange(WatchableViewKeys.name);
+        didViewSchemaChange = true;
+      }
+      if (dirtyPaths.isLocked) {
+        this._onChange(WatchableViewKeys.isLockedView);
+        didViewSchemaChange = true;
+      }
+      return didViewSchemaChange;
+    }
+  }], [{
+    key: "_isWatchableKey",
+    value: /** @internal */
+    function _isWatchableKey(key) {
+      return (0, _private_utils.isEnumValue)(WatchableViewKeys, key);
+    }
+  }]);
+}(_abstract_model.default);
+/** @internal */
+(0, _defineProperty2.default)(View, "_className", 'View');
+var _default = exports.default = View;