@airtable/blocks 1.8.0 → 1.10.0-experimental-48096ae-20211116

package/dist/cjs/models/cursor.js

@@ -89,6 +89,7 @@ var WatchableCursorKeys = Object.freeze({
  *      return (
  *          <div>
  *              Active table: {cursor.activeTableId}
+ *              <br />
  *              Active view: {cursor.activeViewId}
  *          </div>
  *      );
@@ -109,6 +110,7 @@ var WatchableCursorKeys = Object.freeze({
  *      return (
  *          <div>
  *              Selected records: {cursor.selectedRecordIds.join(', ')}
+ *              <br />
  *              Selected fields: {cursor.selectedFieldIds.join(', ')}
  *          </div>
  *      );
@@ -466,4 +468,5 @@ function (_AbstractModelWithAsy) {
 
 (0, _defineProperty2.default)(Cursor, "_className", 'Cursor');
 var _default = Cursor;
-exports.default = _default;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/models/cursor.ts"],"names":["WatchableCursorKeys","Object","freeze","selectedRecordIds","selectedFieldIds","activeTableId","activeViewId","isDataLoaded","Cursor","key","sdk","baseData","__airtableInterface","sdkInitData","selectedRecordIdSet","cursorData","selectedFieldIdSet","activeTable","tablesById","_cursorData","seal","_onChange","_sdk","fetchAndSubscribeToCursorDataAsync","unsubscribeFromCursorData","recordOrRecordId","_data","recordId","Record","id","tableOrTableId","tableId","Table","setActiveViewOrTable","viewOrViewId","viewId","View","changes","changedKeys","path","value","length","didChange","keys","AbstractModelWithAsyncData"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAZA;;AAA+C;AAc/C,IAAMA,mBAAmB,GAAGC,MAAM,CAACC,MAAP,CAAc;AACtCC,EAAAA,iBAAiB,EAAE,mBADmB;AAEtCC,EAAAA,gBAAgB,EAAE,kBAFoB;AAGtCC,EAAAA,aAAa,EAAE,eAHuB;AAItCC,EAAAA,YAAY,EAAE,cAJwB;AAKtCC,EAAAA,YAAY,EAAE;AALwB,CAAd,CAA5B;AAQA;;;;;;;;;AAkBA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+CMC,M;;;;;;;AACF;;AAEA;oCACuBC,G,EAAsB;AACzC,aAAO,gCAAYT,mBAAZ,EAAiCS,GAAjC,CAAP;AACH;AACD;;;;0CAC6BA,G,EAAkC;AAC3D,aAAO,IAAP;AACH;AACD;;;;AAGA;AACA,kBAAYC,GAAZ,EAAsB;AAAA;;AAAA;;AAAA;AAClB,4GAAMA,GAAN,EAAW,QAAX;AADkB;AAGlB,QAAMC,QAAQ,GAAGD,GAAG,CAACE,mBAAJ,CAAwBC,WAAxB,CAAoCF,QAArD;AACA,QAAMG,mBAAmB,mCAAGH,QAAQ,CAACI,UAAZ,yDAAG,qBAAqBD,mBAAxB,uCAA+C,IAAxE;AACA,QAAME,kBAAkB,qCAAGL,QAAQ,CAACI,UAAZ,0DAAG,sBAAqBC,kBAAxB,yCAA8C,IAAtE;AACA,QAAMX,aAAa,GAAGM,QAAQ,CAACN,aAA/B;AACA,QAAMY,WAAW,GAAGZ,aAAa,GAAGM,QAAQ,CAACO,UAAT,CAAoBb,aAApB,CAAH,GAAwC,IAAzE;AACA,QAAMC,YAAY,YAAGW,WAAH,aAAGA,WAAH,uBAAGA,WAAW,CAAEX,YAAhB,yCAAgC,IAAlD;AAEA,UAAKa,WAAL,GAAmB;AACfL,MAAAA,mBADe;AAEfE,MAAAA,kBAFe;AAGfX,MAAAA,aAHe;AAIfC,MAAAA;AAJe,KAAnB;AAOAL,IAAAA,MAAM,CAACmB,IAAP;AAjBkB;AAkBrB;AAED;;;;;;;;AAMA;;;4CAGwB;AACpB,WAAKC,SAAL,CAAerB,mBAAmB,CAACO,YAAnC;AACH;AACD;;;;;;;;;;;;;gDAI6B,KAAKe,IAAL,CAAUV,mBAAV,CAA8BW,kCAA9B,E;;;AAAnBR,cAAAA,U;AACN,mBAAKI,WAAL,CAAiBL,mBAAjB,GAAuCC,UAAU,CAACD,mBAAlD;AACA,mBAAKK,WAAL,CAAiBH,kBAAjB,GAAsCD,UAAU,CAACC,kBAAjD;+CAEO,CAAChB,mBAAmB,CAACG,iBAArB,EAAwCH,mBAAmB,CAACI,gBAA5D,C;;;;;;;;;AAEX;;;;;;kCAGc;AACV,WAAKkB,IAAL,CAAUV,mBAAV,CAA8BY,yBAA9B;;AACA,WAAKL,WAAL,CAAiBL,mBAAjB,GAAuC,IAAvC;AACA,WAAKK,WAAL,CAAiBH,kBAAjB,GAAsC,IAAtC;AACH;AACD;;;;;;;;;;;;AA4BA;;;;;;;;qCAQiBS,gB,EAA4C;AAAA,UAClDX,mBADkD,GAC3B,KAAKY,KADsB,CAClDZ,mBADkD;AAEzD,kCAAUA,mBAAV,EAA+B,2BAA/B;AACA,UAAIa,QAAJ;;AACA,UAAIF,gBAAgB,YAAYG,eAAhC,EAAwC;AACpCD,QAAAA,QAAQ,GAAGF,gBAAgB,CAACI,EAA5B;AACH,OAFD,MAEO;AACHF,QAAAA,QAAQ,GAAGF,gBAAX;AACH;;AACD,aAAO,CAAC,CAACX,mBAAmB,CAACa,QAAD,CAA5B;AACH;AACD;;;;;;;;;;;;;AAyBA;;;;;;;mCAOeG,c,EAAuC;AAClD,UAAMC,OAAO,GAAGD,cAAc,YAAYE,cAA1B,GAAkCF,cAAc,CAACD,EAAjD,GAAsDC,cAAtE;;AACA,WAAKR,IAAL,CAAUV,mBAAV,CAA8BqB,oBAA9B,CAAmDF,OAAnD;AACH;AACD;;;;;;;;;;;kCAQcD,c,EAAiCI,Y,EAAmC;AAC9E,UAAMH,OAAO,GAAGD,cAAc,YAAYE,cAA1B,GAAkCF,cAAc,CAACD,EAAjD,GAAsDC,cAAtE;AACA,UAAMK,MAAM,GAAGD,YAAY,YAAYE,aAAxB,GAA+BF,YAAY,CAACL,EAA5C,GAAiDK,YAAhE;;AACA,WAAKZ,IAAL,CAAUV,mBAAV,CAA8BqB,oBAA9B,CAAmDF,OAAnD,EAA4DI,MAA5D;AACH;AAED;;;;;;0DAIIE,O,EACsC;AACtC,UAAIC,WAAW,GAAG;AACd,SAACtC,mBAAmB,CAACG,iBAArB,GAAyC,KAD3B;AAEd,SAACH,mBAAmB,CAACK,aAArB,GAAqC,KAFvB;AAGd,SAACL,mBAAmB,CAACM,YAArB,GAAoC;AAHtB,OAAlB;AADsC;AAAA;AAAA;;AAAA;AAMtC,6BAA4B+B,OAA5B,8HAAqC;AAAA;AAAA,cAAzBE,IAAyB,eAAzBA,IAAyB;AAAA,cAAnBC,KAAmB,eAAnBA,KAAmB;;AACjC,cAAID,IAAI,CAAC,CAAD,CAAJ,KAAY,YAAhB,EAA8B;AAC1B,oBAAQA,IAAI,CAAC,CAAD,CAAZ;AACI,mBAAK,qBAAL;AAA4B;AACxB,8CAAUA,IAAI,CAACE,MAAL,KAAgB,CAA1B,EAA6B,uCAA7B;AACA,uBAAKtB,WAAL,CAAiBL,mBAAjB,GAAuC0B,KAAvC;AACAF,kBAAAA,WAAW,CAACtC,mBAAmB,CAACG,iBAArB,CAAX,GAAqD,IAArD;AACA;AACH;;AACD,mBAAK,oBAAL;AAA2B;AACvB,8CAAUoC,IAAI,CAACE,MAAL,KAAgB,CAA1B,EAA6B,sCAA7B;AACA,uBAAKtB,WAAL,CAAiBH,kBAAjB,GAAsCwB,KAAtC;AACAF,kBAAAA,WAAW,CAACtC,mBAAmB,CAACI,gBAArB,CAAX,GAAoD,IAApD;AACA;AACH;;AACD,sBAbJ,CAcI;;AAdJ;AAgBH;;AAED,cAAImC,IAAI,CAAC,CAAD,CAAJ,KAAY,eAAhB,EAAiC;AAC7B,wCACIC,KAAK,KAAK,IAAV,IAAkB,OAAOA,KAAP,KAAiB,QADvC,EAEI,sCAFJ;AAKA,iBAAKrB,WAAL,CAAiBd,aAAjB,GAAiCmC,KAAjC;AACAF,YAAAA,WAAW,CAACtC,mBAAmB,CAACK,aAArB,CAAX,GAAiD,IAAjD;;AAEA,gBAAImC,KAAK,KAAK,IAAd,EAAoB;AAChB,mBAAKrB,WAAL,CAAiBb,YAAjB,GAAgC,IAAhC;AACAgC,cAAAA,WAAW,CAACtC,mBAAmB,CAACM,YAArB,CAAX,GAAgD,IAAhD;AACH;AACJ;;AAED,cACIiC,IAAI,CAAC,CAAD,CAAJ,KAAY,YAAZ,IACAA,IAAI,CAAC,CAAD,CAAJ,KAAY,KAAKlC,aADjB,IAEAkC,IAAI,CAAC,CAAD,CAAJ,KAAY,cAHhB,EAIE;AACE,wCACIC,KAAK,KAAK,IAAV,IAAkB,OAAOA,KAAP,KAAiB,QADvC,EAEI,sCAFJ;AAKA,iBAAKrB,WAAL,CAAiBb,YAAjB,GAAgCkC,KAAhC;AACAF,YAAAA,WAAW,CAACtC,mBAAmB,CAACM,YAArB,CAAX,GAAgD,IAAhD;AACH;AACJ;AAtDqC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAwDtC,aAAOgC,WAAP;AACH;AACD;;;;;;oDAGgCA,W,EAAqD;AAAA;AAAA;AAAA;;AAAA;AACjF,8BAA+B,4BAAQA,WAAR,CAA/B,mIAAqD;AAAA;AAAA,cAAzC7B,GAAyC;AAAA,cAApCiC,SAAoC;;AACjD,cAAIA,SAAJ,EAAe;AACX,iBAAKrB,SAAL,CAAeZ,GAAf;AACH;AACJ;AALgF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMpF;;;wBApMsC;AACnC,aAAO,KAAKU,WAAZ;AACH;;;wBAiCwC;AAAA,UAC9BL,mBAD8B,GACP,KAAKY,KADE,CAC9BZ,mBAD8B;AAErC,kCAAUA,mBAAV,EAA+B,2BAA/B;AACA,UAAMX,iBAAiB,GAAGF,MAAM,CAAC0C,IAAP,CAAY7B,mBAAZ,CAA1B;AACA,aAAOX,iBAAP;AACH;AACD;;;;;;;;;;;wBAQwC;AAAA,UAC7Ba,kBAD6B,GACP,KAAKU,KADE,CAC7BV,kBAD6B;AAEpC,kCAAUA,kBAAV,EAA8B,2BAA9B;AACA,UAAMb,iBAAiB,GAAGF,MAAM,CAAC0C,IAAP,CAAY3B,kBAAZ,CAA1B;AACA,aAAOb,iBAAP;AACH;;;wBA6BmC;AAChC,aAAO,KAAKuB,KAAL,CAAWrB,aAAlB;AACH;AACD;;;;;;;;;;;;;wBAUkC;AAC9B,aAAO,KAAKqB,KAAL,CAAWpB,YAAlB;AACH;;;EAxIgBsC,uC;;8BAAfpC,M,gBAEkB,Q;eA2OTA,M","sourcesContent":["/** @module @airtable/blocks/models: Cursor */ /** */\nimport Sdk from '../sdk';\nimport {ModelChange} from '../types/base';\nimport {RecordId} from '../types/record';\nimport {TableId} from '../types/table';\nimport {ViewId} from '../types/view';\nimport {FieldId} from '../types/field';\nimport {isEnumValue, entries, ObjectValues, ObjectMap} from '../private_utils';\nimport {invariant} from '../error_utils';\nimport AbstractModelWithAsyncData from './abstract_model_with_async_data';\nimport Table from './table';\nimport View from './view';\nimport Record from './record';\n\nconst WatchableCursorKeys = Object.freeze({\n    selectedRecordIds: 'selectedRecordIds' as const,\n    selectedFieldIds: 'selectedFieldIds' as const,\n    activeTableId: 'activeTableId' as const,\n    activeViewId: 'activeViewId' as const,\n    isDataLoaded: 'isDataLoaded' as const,\n});\n\n/**\n * Watchable keys in {@link Cursor}.\n * - `selectedRecordIds`\n * - `selectedFieldIds`\n * - `activeTableId`\n * - `activeViewId`\n * - `isDataLoaded`\n */\ntype WatchableCursorKey = ObjectValues<typeof WatchableCursorKeys>;\n\n/** @hidden */\ninterface CursorData {\n    selectedRecordIdSet: ObjectMap<RecordId, boolean> | null;\n    selectedFieldIdSet: ObjectMap<FieldId, boolean> | null;\n    activeTableId: TableId | null;\n    activeViewId: ViewId | null;\n}\n\n// NOTE: cursor is an AbstractModel because it includes loadable data.\n/**\n * Model class containing information about the state of the user's current interactions in\n * Airtable - specifically, their active table, active view, selected records and selected fields.\n * Also allows you to set the active table and active view.\n *\n * Selected records and fields are not loaded by default and the cursor must be loaded with\n * {@link useLoadable} to access them.\n *\n * ```js\n * import {useCursor, useWatchable} from '@airtable/blocks/ui';\n *\n *  function ActiveTableAndView() {\n *      const cursor = useCursor();\n *\n *      return (\n *          <div>\n *              Active table: {cursor.activeTableId}\n *              <br />\n *              Active view: {cursor.activeViewId}\n *          </div>\n *      );\n *  }\n * ```\n *\n * ```js\n * import {useCursor, useLoadable, useWatchable} from '@airtable/blocks/ui';\n *\n *  function SelectedRecordAndFieldIds() {\n *      const cursor = useCursor();\n *      // load selected records and fields\n *      useLoadable(cursor);\n *\n *      // re-render whenever the list of selected records or fields changes\n *      useWatchable(cursor, ['selectedRecordIds', 'selectedFieldIds']);\n *\n *      return (\n *          <div>\n *              Selected records: {cursor.selectedRecordIds.join(', ')}\n *              <br />\n *              Selected fields: {cursor.selectedFieldIds.join(', ')}\n *          </div>\n *      );\n *  }\n * ```\n *\n * @docsPath models/Cursor\n */\nclass Cursor extends AbstractModelWithAsyncData<CursorData, WatchableCursorKey> {\n    /** @internal */\n    static _className = 'Cursor';\n    /** @internal */\n    static _isWatchableKey(key: string): boolean {\n        return isEnumValue(WatchableCursorKeys, key);\n    }\n    /** @internal */\n    static _shouldLoadDataForKey(key: WatchableCursorKey): boolean {\n        return true;\n    }\n    /** @internal */\n    _cursorData: CursorData;\n\n    /** @internal */\n    constructor(sdk: Sdk) {\n        super(sdk, 'cursor');\n\n        const baseData = sdk.__airtableInterface.sdkInitData.baseData;\n        const selectedRecordIdSet = baseData.cursorData?.selectedRecordIdSet ?? null;\n        const selectedFieldIdSet = baseData.cursorData?.selectedFieldIdSet ?? null;\n        const activeTableId = baseData.activeTableId;\n        const activeTable = activeTableId ? baseData.tablesById[activeTableId] : null;\n        const activeViewId = activeTable?.activeViewId ?? null;\n\n        this._cursorData = {\n            selectedRecordIdSet,\n            selectedFieldIdSet,\n            activeTableId,\n            activeViewId,\n        };\n\n        Object.seal(this);\n    }\n\n    /**\n     * @internal\n     */\n    get _dataOrNullIfDeleted(): CursorData {\n        return this._cursorData;\n    }\n    /**\n     * @internal\n     */\n    _onChangeIsDataLoaded() {\n        this._onChange(WatchableCursorKeys.isDataLoaded);\n    }\n    /**\n     * @internal\n     */\n    async _loadDataAsync(): Promise<Array<WatchableCursorKey>> {\n        const cursorData = await this._sdk.__airtableInterface.fetchAndSubscribeToCursorDataAsync();\n        this._cursorData.selectedRecordIdSet = cursorData.selectedRecordIdSet;\n        this._cursorData.selectedFieldIdSet = cursorData.selectedFieldIdSet;\n\n        return [WatchableCursorKeys.selectedRecordIds, WatchableCursorKeys.selectedFieldIds];\n    }\n    /**\n     * @internal\n     */\n    _unloadData() {\n        this._sdk.__airtableInterface.unsubscribeFromCursorData();\n        this._cursorData.selectedRecordIdSet = null;\n        this._cursorData.selectedFieldIdSet = null;\n    }\n    /**\n     * The record IDs of all currently selected records, or an empty array if no records are selected.\n     *\n     * Not loaded by default. You must load cursor data with `useLoadable(cursor)` (recommended) or\n     * `cursor.loadDataAsync()` before use.\n     *\n     * Can be watched.\n     */\n    get selectedRecordIds(): Array<RecordId> {\n        const {selectedRecordIdSet} = this._data;\n        invariant(selectedRecordIdSet, 'Cursor data is not loaded');\n        const selectedRecordIds = Object.keys(selectedRecordIdSet);\n        return selectedRecordIds;\n    }\n    /**\n     * The field IDs of all currently selected fields, or an empty array if no fields are selected.\n     *\n     * Not loaded by default: you must load cursor data with `useLoadable(cursor)` (recommended) or\n     * `cursor.loadDataAsync()` before use.\n     *\n     * Can be watched.\n     */\n    get selectedFieldIds(): Array<RecordId> {\n        const {selectedFieldIdSet} = this._data;\n        invariant(selectedFieldIdSet, 'Cursor data is not loaded');\n        const selectedRecordIds = Object.keys(selectedFieldIdSet);\n        return selectedRecordIds;\n    }\n    /**\n     * Checks whether a given record is selected.\n     *\n     * Selected records are not loaded by default. You must load cursor data with\n     * `useLoadable(cursor)` (recommended) or `cursor.loadDataAsync()` before use.\n     *\n     * @param recordOrRecordId The record or record ID to check for.\n     */\n    isRecordSelected(recordOrRecordId: Record | string): boolean {\n        const {selectedRecordIdSet} = this._data;\n        invariant(selectedRecordIdSet, 'Cursor data is not loaded');\n        let recordId: string;\n        if (recordOrRecordId instanceof Record) {\n            recordId = recordOrRecordId.id;\n        } else {\n            recordId = recordOrRecordId;\n        }\n        return !!selectedRecordIdSet[recordId];\n    }\n    /**\n     * The currently active table ID. Can be null when the active table has changed and is not yet\n     * loaded, and can also refer to a table that is not yet loaded.\n     *\n     * When fetching the {@link Table}, use `base.getTableByIdIfExists(cursor.activeTableId)` and\n     * check the return value is not `null` to be resilient to those cases.\n     *\n     * Can be watched.\n     */\n    get activeTableId(): TableId | null {\n        return this._data.activeTableId;\n    }\n    /**\n     * The currently active view ID. This will always be a view belonging to `activeTableId`. Can be\n     * null when the active view has changed and is not yet loaded, and can also refer to a view\n     * that is not yet loaded.\n     *\n     * When fetching the {@link View}, use `table.getViewByIdIfExists(cursor.activeViewId)` and\n     * check the return value is not `null` to be resilient to those cases.\n     *\n     * Can be watched.\n     */\n    get activeViewId(): ViewId | null {\n        return this._data.activeViewId;\n    }\n    /**\n     * Sets the specified table to active in the Airtable UI. If the apps pane is fullscreen, the\n     * table will still be set as active, but the apps pane will continue to be displayed\n     * fullscreen.\n     *\n     * @param tableOrTableId The target table or table ID to set as active in the Airtable main page.\n     */\n    setActiveTable(tableOrTableId: Table | TableId): void {\n        const tableId = tableOrTableId instanceof Table ? tableOrTableId.id : tableOrTableId;\n        this._sdk.__airtableInterface.setActiveViewOrTable(tableId);\n    }\n    /**\n     * Sets the specified view (and corresponding table) to active in the Airtable UI. If the apps\n     * pane is fullscreen, the view will still be set as active, but the apps pane will continue\n     * to be displayed fullscreen.\n     *\n     * @param tableOrTableId The table or table ID that the target view belongs to.\n     * @param viewOrViewId The target view or view ID to set as active in the Airtable main page.\n     */\n    setActiveView(tableOrTableId: Table | TableId, viewOrViewId: View | ViewId): void {\n        const tableId = tableOrTableId instanceof Table ? tableOrTableId.id : tableOrTableId;\n        const viewId = viewOrViewId instanceof View ? viewOrViewId.id : viewOrViewId;\n        this._sdk.__airtableInterface.setActiveViewOrTable(tableId, viewId);\n    }\n\n    /**\n     * @internal\n     */\n    __applyChangesWithoutTriggeringEvents(\n        changes: ReadonlyArray<ModelChange>,\n    ): ObjectMap<WatchableCursorKey, boolean> {\n        let changedKeys = {\n            [WatchableCursorKeys.selectedRecordIds]: false,\n            [WatchableCursorKeys.activeTableId]: false,\n            [WatchableCursorKeys.activeViewId]: false,\n        } as ObjectMap<WatchableCursorKey, boolean>;\n        for (const {path, value} of changes) {\n            if (path[0] === 'cursorData') {\n                switch (path[1]) {\n                    case 'selectedRecordIdSet': {\n                        invariant(path.length === 2, 'cannot set within selectedRecordIdSet');\n                        this._cursorData.selectedRecordIdSet = value as any;\n                        changedKeys[WatchableCursorKeys.selectedRecordIds] = true;\n                        break;\n                    }\n                    case 'selectedFieldIdSet': {\n                        invariant(path.length === 2, 'cannot set within selectedFieldIdSet');\n                        this._cursorData.selectedFieldIdSet = value as any;\n                        changedKeys[WatchableCursorKeys.selectedFieldIds] = true;\n                        break;\n                    }\n                    default:\n                    // No-op for future unknown paths.\n                }\n            }\n\n            if (path[0] === 'activeTableId') {\n                invariant(\n                    value === null || typeof value === 'string',\n                    'activeTableId must be string or null',\n                );\n\n                this._cursorData.activeTableId = value;\n                changedKeys[WatchableCursorKeys.activeTableId] = true;\n\n                if (value === null) {\n                    this._cursorData.activeViewId = null;\n                    changedKeys[WatchableCursorKeys.activeViewId] = true;\n                }\n            }\n\n            if (\n                path[0] === 'tablesById' &&\n                path[1] === this.activeTableId &&\n                path[2] === 'activeViewId'\n            ) {\n                invariant(\n                    value === null || typeof value === 'string',\n                    'activeTableId must be string or null',\n                );\n\n                this._cursorData.activeViewId = value;\n                changedKeys[WatchableCursorKeys.activeViewId] = true;\n            }\n        }\n\n        return changedKeys;\n    }\n    /**\n     * @internal\n     */\n    __triggerOnChangeForChangedKeys(changedKeys: ObjectMap<WatchableCursorKey, boolean>) {\n        for (const [key, didChange] of entries(changedKeys)) {\n            if (didChange) {\n                this._onChange(key);\n            }\n        }\n    }\n}\n\nexport default Cursor;\n"]}

package/dist/cjs/models/field.js

@@ -109,7 +109,9 @@ function (_AbstractModel) {
     (0, _classCallCheck2.default)(this, Field);
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Field).call(this, sdk, fieldId));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentTable", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cachedFieldTypeConfigOrNull", void 0);
     _this._parentTable = parentTable;
+    _this._cachedFieldTypeConfigOrNull = null;
     return _this;
   }
   /**
@@ -118,6 +120,42 @@ function (_AbstractModel) {
 
 
   (0, _createClass2.default)(Field, [{
+    key: "_getCachedConfigFromFieldTypeProvider",
+    // We use a cached response from FieldTypeProvider because getting the config can
+    // be an expensive operation. In particular when fieldConfigs are extremely large
+    // (eg: Select fields with lots of select options)
+    value: function _getCachedConfigFromFieldTypeProvider() {
+      if (this._cachedFieldTypeConfigOrNull !== null) {
+        return this._cachedFieldTypeConfigOrNull;
+      }
+
+      var airtableInterface = this._sdk.__airtableInterface;
+      var appInterface = this._sdk.__appInterface;
+      this._cachedFieldTypeConfigOrNull = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById());
+      return this._cachedFieldTypeConfigOrNull;
+    }
+  }, {
+    key: "_clearCachedConfig",
+    value: function _clearCachedConfig() {
+      this._cachedFieldTypeConfigOrNull = null;
+    }
+    /**
+     * The type and options of the field to make type narrowing `FieldOptions` easier.
+     *
+     * @see {@link FieldConfig}
+     * @example
+     * const fieldConfig = field.config;
+     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
+     *     return fieldConfig.options.choices;
+     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
+     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
+     *         return fieldConfig.options.result.options.choices;
+     *     }
+     * }
+     * return DEFAULT_CHOICES;
+     */
+
+  }, {
     key: "checkPermissionsForUpdateOptions",
 
     /**
@@ -125,7 +163,7 @@ function (_AbstractModel) {
      *
      * Accepts partial input, in the same format as {@link updateOptionsAsync}.
      *
-     * Returns `{hasPermission: true}` if the current user can update the specified record,
+     * Returns `{hasPermission: true}` if the current user can update the specified field,
      * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
      * used to display an error message to the user.
      *
@@ -241,6 +279,104 @@ function (_AbstractModel) {
         }
       }, null, this);
     }
+    /**
+     * Checks whether the current user has permission to perform the given description update.
+     *
+     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.
+     *
+     * Returns `{hasPermission: true}` if the current user can update the specified field,
+     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+     * used to display an error message to the user.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * const updateFieldCheckResult = field.checkPermissionsForUpdateDescription();
+     *
+     * if (!updateFieldCheckResult.hasPermission) {
+     *     alert(updateFieldCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+
+  }, {
+    key: "checkPermissionsForUpdateDescription",
+    value: function checkPermissionsForUpdateDescription(description) {
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
+        tableId: this.parentTable.id,
+        id: this.id,
+        description
+      });
+    }
+    /**
+     * An alias for `checkPermissionsForUpdateDescription(options).hasPermission`.
+     *
+     * Checks whether the current user has permission to perform the description update.
+     *
+     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * const canUpdateField = field.hasPermissionToUpdateDescription();
+     *
+     * if (!canUpdateField) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+
+  }, {
+    key: "hasPermissionToUpdateDescription",
+    value: function hasPermissionToUpdateDescription(description) {
+      return this.checkPermissionsForUpdateDescription(description).hasPermission;
+    }
+    /**
+     * Updates the description for this field.
+     *
+     * To remove an existing description, pass `''` as the new description.
+     * `null` is also accepted and will be coerced to `''` for consistency with field creation.
+     *
+     * Throws an error if the user does not have permission to update the field, or if an invalid
+     * description is provided.
+     *
+     * This action is asynchronous. Unlike updates to cell values, updates to field descriptions are
+     * **not** applied optimistically locally. You must `await` the returned promise before
+     * relying on the change in your app.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * await myTextField.updateDescriptionAsync('This is a text field');
+     * ```
+     */
+
+  }, {
+    key: "updateDescriptionAsync",
+    value: function updateDescriptionAsync(description) {
+      return _regenerator.default.async(function updateDescriptionAsync$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return _regenerator.default.awrap(this._sdk.__mutations.applyMutationAsync({
+                type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
+                tableId: this.parentTable.id,
+                id: this.id,
+                description
+              }));
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    }
     /**
      * `true` if this field is computed, `false` otherwise. A field is
      * "computed" if it's value is not set by user input (e.g. autoNumber, formula,
@@ -329,6 +465,9 @@ function (_AbstractModel) {
   }, {
     key: "__triggerOnChangeForDirtyPaths",
     value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      // Always clear the cached config when anything on the field data model changes
+      this._clearCachedConfig();
+
       if (dirtyPaths.name) {
         this._onChange(WatchableFieldKeys.name);
       }
@@ -402,11 +541,8 @@ function (_AbstractModel) {
   }, {
     key: "type",
     get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-
-      var _airtableInterface$fi = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById()),
-          type = _airtableInterface$fi.type; // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
+      var _this$_getCachedConfi = this._getCachedConfigFromFieldTypeProvider(),
+          type = _this$_getCachedConfi.type; // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
       // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.
       // @ts-ignore
 
@@ -437,31 +573,14 @@ function (_AbstractModel) {
   }, {
     key: "options",
     get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-
-      var _airtableInterface$fi2 = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById()),
-          options = _airtableInterface$fi2.options; // TODO(emma): can we remove this cloneDeep?
+      var _this$_getCachedConfi2 = this._getCachedConfigFromFieldTypeProvider(),
+          options = _this$_getCachedConfi2.options; // TODO: In the next breaking release freeze (inside of the cache) and replace
+      // FieldOptions with readonly<FieldOptions>.
+      // Today this is required because we re-use the fieldTypeProvider.getConfig response.
 
 
       return options ? (0, _private_utils.cloneDeep)(options) : null;
     }
-    /**
-     * The type and options of the field to make type narrowing `FieldOptions` easier.
-     *
-     * @see {@link FieldConfig}
-     * @example
-     * const fieldConfig = field.config;
-     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
-     *     return fieldConfig.options.choices;
-     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
-     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
-     *         return fieldConfig.options.result.options.choices;
-     *     }
-     * }
-     * return DEFAULT_CHOICES;
-     */
-
   }, {
     key: "config",
     get: function get() {
@@ -532,4 +651,5 @@ function (_AbstractModel) {
 
 (0, _defineProperty2.default)(Field, "_className", 'Field');
 var _default = Field;
-exports.default = _default;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/models/field.ts"],"names":["WatchableFieldKeys","Object","freeze","name","type","options","isComputed","description","Field","key","sdk","parentTable","fieldId","_parentTable","_cachedFieldTypeConfigOrNull","airtableInterface","_sdk","__airtableInterface","appInterface","__appInterface","fieldTypeProvider","getConfig","_data","__getFieldNamesById","__mutations","checkPermissionsForMutation","MutationTypes","UPDATE_SINGLE_FIELD_CONFIG","tableId","id","config","checkPermissionsForUpdateOptions","hasPermission","opts","applyMutationAsync","UPDATE_SINGLE_FIELD_DESCRIPTION","checkPermissionsForUpdateDescription","aggregator","aggregatorKey","availableAggregatorKeys","aggregators","getAvailableAggregatorKeysForField","some","string","cellValue","convertStringToCellValue","validationResult","validateCellValueForUpdate","isValid","dirtyPaths","_clearCachedConfig","_onChange","typeOptions","tableData","_baseData","tablesById","fieldsById","_id","_getCachedConfigFromFieldTypeProvider","FieldType","MULTIPLE_LOOKUP_VALUES","primaryField","availableAggregatorKeysSet","Set","require","filter","has","AbstractModel"],"mappings":"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","sourcesContent":["/** @module @airtable/blocks/models: Field */ /** */\nimport {AggregatorKey} from '../types/aggregators';\nimport Sdk from '../sdk';\nimport {MutationTypes, PermissionCheckResult, UpdateFieldOptionsOpts} from '../types/mutations';\nimport {FieldData, FieldType, FieldOptions, FieldConfig} from '../types/field';\nimport {isEnumValue, cloneDeep, values, ObjectValues, FlowAnyObject} from '../private_utils';\nimport {FieldTypeConfig} from '../types/airtable_interface';\nimport AbstractModel from './abstract_model';\nimport {Aggregator} from './create_aggregators';\nimport Table from './table';\n\n// This doesn't follow our enum naming conventions because we want the keys\n// to mirror the method/getter names on the model class.\nconst WatchableFieldKeys = Object.freeze({\n    name: 'name' as const,\n    type: 'type' as const,\n    options: 'options' as const,\n    isComputed: 'isComputed' as const,\n    description: 'description' as const,\n});\n\n/**\n * All the watchable keys in a field.\n * - `name`\n * - `type`\n * - `options`\n * - `isComputed`\n * - `description`\n */\nexport type WatchableFieldKey = ObjectValues<typeof WatchableFieldKeys>;\n\n/**\n * Model class representing a field in a table.\n *\n * @example\n * ```js\n * import {base} from '@airtable/blocks';\n *\n * const table = base.getTableByName('Table 1');\n * const field = table.getFieldByName('Name');\n * console.log('The type of this field is', field.type);\n * ```\n * @docsPath models/Field\n */\nclass Field extends AbstractModel<FieldData, WatchableFieldKey> {\n    /** @internal */\n    static _className = 'Field';\n    /** @internal */\n    static _isWatchableKey(key: string) {\n        return isEnumValue(WatchableFieldKeys, key);\n    }\n    /** @internal */\n    _parentTable: Table;\n    /** @internal */\n    _cachedFieldTypeConfigOrNull: FieldTypeConfig | null;\n    /**\n     * @internal\n     */\n    constructor(sdk: Sdk, parentTable: Table, fieldId: string) {\n        super(sdk, fieldId);\n\n        this._parentTable = parentTable;\n        this._cachedFieldTypeConfigOrNull = null;\n    }\n\n    /**\n     * @internal\n     */\n    get _dataOrNullIfDeleted(): FieldData | null {\n        const tableData = this._baseData.tablesById[this.parentTable.id];\n        return tableData?.fieldsById[this._id] ?? null;\n    }\n    /**\n     * The table that this field belongs to. Should never change because fields aren't moved between tables.\n     *\n     * @internal (since we may not be able to return parent model instances in the immutable models world)\n     * @example\n     * ```js\n     * const field = myTable.getFieldByName('Name');\n     * console.log(field.parentTable.id === myTable.id);\n     * // => true\n     * ```\n     */\n    get parentTable(): Table {\n        return this._parentTable;\n    }\n    /**\n     * The name of the field. Can be watched.\n     *\n     * @example\n     * ```js\n     * console.log(myField.name);\n     * // => 'Name'\n     * ```\n     */\n    get name(): string {\n        return this._data.name;\n    }\n    /**\n     * The type of the field. Can be watched.\n     *\n     * @example\n     * ```js\n     * console.log(myField.type);\n     * // => 'singleLineText'\n     * ```\n     */\n    get type(): FieldType {\n        const {type} = this._getCachedConfigFromFieldTypeProvider();\n        // We intend to switch from \"lookup\" to \"multipleLookupValues\", but need to support both\n        // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.\n        // @ts-ignore\n        if (type === 'lookup') {\n            return FieldType.MULTIPLE_LOOKUP_VALUES;\n        } else {\n            return type;\n        }\n    }\n    /**\n     * The configuration options of the field. The structure of the field's\n     * options depend on the field's type. `null` if the field has no options.\n     * Can be watched.\n     *\n     * @see {@link FieldType}\n     * @example\n     * ```js\n     * import {FieldType} from '@airtable/blocks/models';\n     *\n     * if (myField.type === FieldType.CURRENCY) {\n     *     console.log(myField.options.symbol);\n     *     // => '$'\n     * }\n     * ```\n     */\n    get options(): FieldOptions | null {\n        const {options} = this._getCachedConfigFromFieldTypeProvider();\n\n        // TODO: In the next breaking release freeze (inside of the cache) and replace\n        // FieldOptions with readonly<FieldOptions>.\n        // Today this is required because we re-use the fieldTypeProvider.getConfig response.\n        return options ? cloneDeep(options) : null;\n    }\n\n    // We use a cached response from FieldTypeProvider because getting the config can\n    // be an expensive operation. In particular when fieldConfigs are extremely large\n    // (eg: Select fields with lots of select options)\n    _getCachedConfigFromFieldTypeProvider(): FieldTypeConfig {\n        if (this._cachedFieldTypeConfigOrNull !== null) {\n            return this._cachedFieldTypeConfigOrNull;\n        }\n        const airtableInterface = this._sdk.__airtableInterface;\n        const appInterface = this._sdk.__appInterface;\n\n        this._cachedFieldTypeConfigOrNull = airtableInterface.fieldTypeProvider.getConfig(\n            appInterface,\n            this._data,\n            this.parentTable.__getFieldNamesById(),\n        );\n\n        return this._cachedFieldTypeConfigOrNull;\n    }\n    _clearCachedConfig(): void {\n        this._cachedFieldTypeConfigOrNull = null;\n    }\n\n    /**\n     * The type and options of the field to make type narrowing `FieldOptions` easier.\n     *\n     * @see {@link FieldConfig}\n     * @example\n     * const fieldConfig = field.config;\n     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {\n     *     return fieldConfig.options.choices;\n     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {\n     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {\n     *         return fieldConfig.options.result.options.choices;\n     *     }\n     * }\n     * return DEFAULT_CHOICES;\n     */\n    get config(): FieldConfig {\n        return {\n            type: this.type,\n            options: this.options,\n        } as FieldConfig;\n    }\n    /**\n     * Checks whether the current user has permission to perform the given options update.\n     *\n     * Accepts partial input, in the same format as {@link updateOptionsAsync}.\n     *\n     * Returns `{hasPermission: true}` if the current user can update the specified field,\n     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be\n     * used to display an error message to the user.\n     *\n     * @param options new options for the field\n     *\n     * @example\n     * ```js\n     * const updateFieldCheckResult = field.checkPermissionsForUpdateOptions();\n     *\n     * if (!updateFieldCheckResult.hasPermission) {\n     *     alert(updateFieldCheckResult.reasonDisplayString);\n     * }\n     * ```\n     */\n    checkPermissionsForUpdateOptions(options?: FieldOptions): PermissionCheckResult {\n        return this._sdk.__mutations.checkPermissionsForMutation({\n            type: MutationTypes.UPDATE_SINGLE_FIELD_CONFIG,\n            tableId: this.parentTable.id,\n            id: this.id,\n            config: {\n                type: this.type,\n                options: options,\n            },\n        });\n    }\n\n    /**\n     * An alias for `checkPermissionsForUpdateOptions(options).hasPermission`.\n     *\n     * Checks whether the current user has permission to perform the options update.\n     *\n     * Accepts partial input, in the same format as {@link updateOptionsAsync}.\n     *\n     * @param options new options for the field\n     *\n     * @example\n     * ```js\n     * const canUpdateField = field.hasPermissionToUpdateOptions();\n     *\n     * if (!canUpdateField) {\n     *     alert('not allowed!');\n     * }\n     * ```\n     */\n    hasPermissionToUpdateOptions(options?: FieldOptions): boolean {\n        return this.checkPermissionsForUpdateOptions(options).hasPermission;\n    }\n\n    /**\n     * Updates the options for this field.\n     *\n     * Throws an error if the user does not have permission to update the field, if invalid\n     * options are provided, if this field has no writable options, or if updates to this field\n     * type is not supported.\n     *\n     * Refer to {@link FieldType} for supported field types, the write format for options, and\n     * other specifics for certain field types.\n     *\n     * This action is asynchronous. Unlike updates to cell values, updates to field options are\n     * **not** applied optimistically locally. You must `await` the returned promise before\n     * relying on the change in your app.\n     *\n     * Optionally, you can pass an `opts` object as the second argument. See {@link UpdateFieldOptionsOpts}\n     * for available options.\n     *\n     * @param options new options for the field\n     * @param opts optional options to affect the behavior of the update\n     *\n     * @example\n     * ```js\n     * async function addChoiceToSelectField(selectField, nameForNewOption) {\n     *     const updatedOptions = {\n     *         choices: [\n     *             ...selectField.options.choices,\n     *             {name: nameForNewOption},\n     *         ]\n     *     };\n     *\n     *     if (selectField.hasPermissionToUpdateOptions(updatedOptions)) {\n     *         await selectField.updateOptionsAsync(updatedOptions);\n     *     }\n     * }\n     * ```\n     */\n    async updateOptionsAsync(\n        options: FieldOptions,\n        opts: UpdateFieldOptionsOpts = {},\n    ): Promise<void> {\n        await this._sdk.__mutations.applyMutationAsync({\n            type: MutationTypes.UPDATE_SINGLE_FIELD_CONFIG,\n            tableId: this.parentTable.id,\n            id: this.id,\n            config: {\n                type: this.type,\n                options: options,\n            },\n            opts,\n        });\n    }\n\n    /**\n     * Checks whether the current user has permission to perform the given description update.\n     *\n     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.\n     *\n     * Returns `{hasPermission: true}` if the current user can update the specified field,\n     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be\n     * used to display an error message to the user.\n     *\n     * @param description new description for the field\n     *\n     * @example\n     * ```js\n     * const updateFieldCheckResult = field.checkPermissionsForUpdateDescription();\n     *\n     * if (!updateFieldCheckResult.hasPermission) {\n     *     alert(updateFieldCheckResult.reasonDisplayString);\n     * }\n     * ```\n     */\n    checkPermissionsForUpdateDescription(description?: string | null): PermissionCheckResult {\n        return this._sdk.__mutations.checkPermissionsForMutation({\n            type: MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,\n            tableId: this.parentTable.id,\n            id: this.id,\n            description,\n        });\n    }\n\n    /**\n     * An alias for `checkPermissionsForUpdateDescription(options).hasPermission`.\n     *\n     * Checks whether the current user has permission to perform the description update.\n     *\n     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.\n     *\n     * @param description new description for the field\n     *\n     * @example\n     * ```js\n     * const canUpdateField = field.hasPermissionToUpdateDescription();\n     *\n     * if (!canUpdateField) {\n     *     alert('not allowed!');\n     * }\n     * ```\n     */\n    hasPermissionToUpdateDescription(description?: string | null): boolean {\n        return this.checkPermissionsForUpdateDescription(description).hasPermission;\n    }\n\n    /**\n     * Updates the description for this field.\n     *\n     * To remove an existing description, pass `''` as the new description.\n     * `null` is also accepted and will be coerced to `''` for consistency with field creation.\n     *\n     * Throws an error if the user does not have permission to update the field, or if an invalid\n     * description is provided.\n     *\n     * This action is asynchronous. Unlike updates to cell values, updates to field descriptions are\n     * **not** applied optimistically locally. You must `await` the returned promise before\n     * relying on the change in your app.\n     *\n     * @param description new description for the field\n     *\n     * @example\n     * ```js\n     * await myTextField.updateDescriptionAsync('This is a text field');\n     * ```\n     */\n    async updateDescriptionAsync(description: string | null): Promise<void> {\n        await this._sdk.__mutations.applyMutationAsync({\n            type: MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,\n            tableId: this.parentTable.id,\n            id: this.id,\n            description,\n        });\n    }\n\n    /**\n     * `true` if this field is computed, `false` otherwise. A field is\n     * \"computed\" if it's value is not set by user input (e.g. autoNumber, formula,\n     * etc.). Can be watched\n     *\n     * @example\n     * ```js\n     * console.log(mySingleLineTextField.isComputed);\n     * // => false\n     * console.log(myAutoNumberField.isComputed);\n     * // => true\n     * ```\n     */\n    get isComputed(): boolean {\n        const airtableInterface = this._sdk.__airtableInterface;\n        return airtableInterface.fieldTypeProvider.isComputed(this._data);\n    }\n    /**\n     * `true` if this field is its parent table's primary field, `false` otherwise.\n     * Should never change because the primary field of a table cannot change.\n     */\n    get isPrimaryField(): boolean {\n        return this.id === this.parentTable.primaryField.id;\n    }\n\n    /**\n     * The description of the field, if it has one. Can be watched.\n     *\n     * @example\n     * ```js\n     * console.log(myField.description);\n     * // => 'This is my field'\n     * ```\n     */\n    get description(): string | null {\n        return this._data.description;\n    }\n    // The following method is untested because its implementation resists\n    // testing and because it is expected to be redesigned.\n    // istanbul ignore next\n    /**\n     * A list of available aggregators given this field's configuration.\n     *\n     * @example\n     * ```js\n     * const fieldAggregators = myField.availableAggregators;\n     * ```\n     */\n    get availableAggregators(): Array<Aggregator> {\n        const airtableInterface = this._sdk.__airtableInterface;\n        const availableAggregatorKeysSet = new Set(\n            airtableInterface.aggregators.getAvailableAggregatorKeysForField(this._data),\n        );\n\n        const {aggregators} = require('./models');\n        return values(aggregators).filter(aggregator => {\n            return availableAggregatorKeysSet.has(aggregator.key);\n        });\n    }\n    // The following method is untested because its implementation resists\n    // testing and because it is expected to be redesigned.\n    // istanbul ignore next\n    /**\n     * Checks if the given aggregator is available for this field.\n     *\n     * @param aggregator The aggregator object or aggregator key.\n     * @example\n     * ```js\n     * import {aggregators} from '@airtable/blocks/models';\n     * const aggregator = aggregators.totalAttachmentSize;\n     *\n     * // Using an aggregator object\n     * console.log(myAttachmentField.isAggregatorAvailable(aggregator));\n     * // => true\n     *\n     * // Using an aggregator key\n     * console.log(myTextField.isAggregatorAvailable('totalAttachmentSize'));\n     * // => false\n     * ```\n     */\n    isAggregatorAvailable(aggregator: Aggregator | AggregatorKey): boolean {\n        const aggregatorKey = typeof aggregator === 'string' ? aggregator : aggregator.key;\n\n        const airtableInterface = this._sdk.__airtableInterface;\n        const availableAggregatorKeys = airtableInterface.aggregators.getAvailableAggregatorKeysForField(\n            this._data,\n        );\n\n        return availableAggregatorKeys.some(key => key === aggregatorKey);\n    }\n    /**\n     * Attempt to parse a given string and return a valid cell value for the field's current config.\n     * Returns `null` if unable to parse the given string.\n     *\n     * @param string The string to parse.\n     * @example\n     * ```js\n     * const inputString = '42';\n     * const cellValue = myNumberField.convertStringToCellValue(inputString);\n     * console.log(cellValue === 42);\n     * // => true\n     * ```\n     */\n    convertStringToCellValue(string: string): unknown {\n        const airtableInterface = this._sdk.__airtableInterface;\n        const appInterface = this._sdk.__appInterface;\n\n        const cellValue = airtableInterface.fieldTypeProvider.convertStringToCellValue(\n            appInterface,\n            string,\n            this._data,\n        );\n\n        // Temporarily bail out of validating computed values (since validation will crash)\n        // while we work out if we actually have to validate or not. Ideally we just delete all\n        // the validation\n        // TODO(emma): delete me or tidy me up\n        if (this.isComputed) {\n            return cellValue;\n        }\n\n        // TODO(emma): do we need to validate here?\n        const validationResult = airtableInterface.fieldTypeProvider.validateCellValueForUpdate(\n            appInterface,\n            cellValue,\n            null,\n            this._data,\n        );\n\n        if (validationResult.isValid) {\n            return cellValue;\n        } else {\n            return null;\n        }\n    }\n    /**\n     * @internal\n     */\n    __triggerOnChangeForDirtyPaths(dirtyPaths: FlowAnyObject) {\n        // Always clear the cached config when anything on the field data model changes\n        this._clearCachedConfig();\n\n        if (dirtyPaths.name) {\n            this._onChange(WatchableFieldKeys.name);\n        }\n        if (dirtyPaths.type) {\n            this._onChange(WatchableFieldKeys.type);\n\n            // TODO: it would be better if we only trigger this when\n            // we know isComputed changed.\n            this._onChange(WatchableFieldKeys.isComputed);\n        }\n        if (dirtyPaths.typeOptions) {\n            this._onChange(WatchableFieldKeys.options);\n        }\n        if (dirtyPaths.description) {\n            this._onChange(WatchableFieldKeys.description);\n        }\n    }\n}\n\nexport default Field;\n"]}

package/dist/cjs/models/grouped_record_query_result.js

@@ -245,19 +245,13 @@ function (_RecordQueryResult) {
         while (1) {
           switch (_context2.prev = _context2.next) {
             case 0:
-              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this); // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
-              // TODO: (SeanKeenan) At the moment this should never be relevant, because groups are recreated
-              // anytime the groups change - but this is how it should work once groups persist AND
-              // watching recordIds only changes if records in this group change.
-              // In the meantime this does ensure that a deleted GroupedRecordQuery with stale recordIds
-              // doesn't return the cached array.
+              // TODO: This entire class assumes it is torn down and re-created by the parent whenever
+              // a change to the group is made.
+              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this);
 
-
-              this.watch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
-              this.watch(['recordIds'], this._invalidateRecordIdsSet, this);
               return _context2.abrupt("return", this._getChangedKeysOnLoad());
 
-            case 4:
+            case 2:
             case "end":
               return _context2.stop();
           }
@@ -269,10 +263,7 @@ function (_RecordQueryResult) {
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
-      this.unwatch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
-      this.unwatch(['recordIds'], this._invalidateRecordIdsSet, this); // Invalidate both of the caches, as this object can no longer be accessed
-
+      // Invalidate both of the caches, as this object can no longer be accessed
       this._invalidateComputedRecordIds();
 
       this._invalidateRecordIdsSet();
@@ -472,4 +463,5 @@ function (_RecordQueryResult) {
 
 (0, _defineProperty2.default)(GroupedRecordQueryResult, "_className", 'GroupedRecordQueryResult');
 var _default = GroupedRecordQueryResult;
-exports.default = _default;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/models/grouped_record_query_result.ts"],"names":["GroupedRecordQueryResult","parentQueryResult","groupData","groupLevel","normalizedOpts","sdk","__groupedRecordQueryResultPool","ObjectPool","_parentQueryResult","_groupData","_groupLevels","groupLevelDataSlicedForChildren","slice","_orderedChildrenGroups","groups","map","singleGroupData","group","getObjectForReuse","loadDataAsync","_data","visibleRecordIds","recordIds","push","_orderedRecordIds","keys","callback","context","validKeys","watch","unwatch","_getChangedKeysOnLoad","registerObjectForReuseStrong","_invalidateComputedRecordIds","_invalidateRecordIdsSet","_unloadChildrenGroupsIfNeeded","unregisterObjectForReuseStrong","unloadData","_recordIdsSet","recordIdsSet","recordId","groupLevels","fieldId","parentTable","getFieldById","isDataLoaded","_computeRecordIds","fields","_serializedOpts","id","_dataOrNullIfDeleted","RecordQueryResult"],"mappings":"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","sourcesContent":["/** @module @airtable/blocks/models: RecordQueryResult */ /** */\nimport {FieldId} from '../types/field';\nimport Sdk from '../sdk';\nimport {FlowAnyFunction, FlowAnyObject, ObjectMap} from '../private_utils';\nimport {invariant} from '../error_utils';\nimport {RecordId} from '../types/record';\nimport {GroupData} from '../types/view';\nimport {NormalizedGroupLevel} from '../types/airtable_interface';\nimport RecordQueryResult, {\n    WatchableRecordQueryResultKey,\n    NormalizedRecordQueryResultOpts,\n} from './record_query_result';\n\nimport Table from './table';\nimport Field from './field';\nimport ObjectPool from './object_pool';\nimport TableOrViewQueryResult from './table_or_view_query_result';\n\n/** @hidden */\n// Even though we don't load the data, we still access it through `._data` so that\n// we can be ensured the model hasn't been deleted.\ninterface GroupedRecordQueryResultData {\n    groupData: GroupData;\n    groupLevels: ReadonlyArray<NormalizedGroupLevel>;\n}\n\n/**\n * Represents a group of records returned from a group query. See {@link RecordQueryResult} for main\n * documentation.\n *\n * Do not instantiate. You can get instances of this class by calling\n * `recordQueryResult.groups`.\n *\n * @docsPath models/query results/GroupedRecordQueryResult\n * @hidden\n */\nclass GroupedRecordQueryResult extends RecordQueryResult<GroupedRecordQueryResultData> {\n    /** @internal */\n    static _className = 'GroupedRecordQueryResult';\n\n    /** @internal */\n    _parentQueryResult: TableOrViewQueryResult | GroupedRecordQueryResult;\n\n    /** @internal */\n    _groupData: GroupData;\n\n    /**\n     * This includes groupLevel for all children & parent grouped layers, the getter\n     * returns only the groupLevels for this layer.\n     *\n     * @internal\n     */\n    _groupLevels: ReadonlyArray<NormalizedGroupLevel>;\n\n    // This is the ordered list of groups.\n    /** @internal */\n    _orderedChildrenGroups: Array<GroupedRecordQueryResult> | null;\n\n    // lazily generated set of record ids\n    /** @internal */\n    _recordIdsSet: {[key: string]: true | void} | null = null;\n\n    // lazily generated ordered array of recordIds\n    _orderedRecordIds: ReadonlyArray<RecordId> | null = null;\n\n    /** @internal */\n    __groupedRecordQueryResultPool: ObjectPool<\n        GroupedRecordQueryResult,\n        typeof GroupedRecordQueryResult\n    >;\n\n    /** @internal */\n    constructor(\n        parentQueryResult: TableOrViewQueryResult | GroupedRecordQueryResult,\n        groupData: GroupData,\n        groupLevel: ReadonlyArray<NormalizedGroupLevel>,\n        normalizedOpts: NormalizedRecordQueryResultOpts,\n        sdk: Sdk,\n    ) {\n        super(sdk, normalizedOpts);\n\n        this.__groupedRecordQueryResultPool = new ObjectPool(GroupedRecordQueryResult);\n        this._parentQueryResult = parentQueryResult;\n        this._groupData = groupData;\n        this._groupLevels = groupLevel;\n        const groupLevelDataSlicedForChildren = this._groupLevels.slice(1);\n        this._orderedChildrenGroups = groupData.groups\n            ? groupData.groups.map(singleGroupData => {\n                  const group = this.__groupedRecordQueryResultPool.getObjectForReuse(\n                      this,\n                      singleGroupData,\n                      groupLevelDataSlicedForChildren,\n                      normalizedOpts,\n                      sdk,\n                  );\n                  // Don't await the loading, let others check isDataLoaded.\n                  // (it doesn't take any time anyway). Loading also strong retains.\n                  group.loadDataAsync();\n                  return group;\n              })\n            : null;\n    }\n\n    /**\n     * Gets children groups of this group (if any exist)\n     */\n    get groups(): Array<GroupedRecordQueryResult> | null {\n        return this._orderedChildrenGroups;\n    }\n\n    /** @internal */\n    get groupLevel(): NormalizedGroupLevel {\n        return this._data.groupLevels[0];\n    }\n\n    /**\n     * Gets the fieldId that this group is grouped by\n     */\n    get fieldId(): FieldId {\n        return this.groupLevel.fieldId;\n    }\n\n    /**\n     * Gets the field that this group is grouped by\n     */\n    get field(): Field {\n        return this.parentTable.getFieldById(this.fieldId);\n    }\n\n    // TODO (SeanKeenan) This is needed because we can't always iterate down and find\n    // a record, it's possible to have \"empty groups\".\n    // getValue() {\n    // }\n\n    // TODO (SeanKeenan)\n    // getValueAsString() {\n    // }\n\n    /**\n     * @internal (since we may not be able to return parent model instances in the immutable models world)\n     * The table that records in this RecordQueryResult are part of\n     */\n    get parentTable(): Table {\n        return this._parentQueryResult.parentTable;\n    }\n\n    /**\n     * Recursively gets all recordIds in the children groups, keeping recordIds in group order\n     *\n     * @internal\n     */\n    _computeRecordIds(): ReadonlyArray<RecordId> {\n        // If we are a leaf node, return the raw recordIds\n        if (!this.groups) {\n            // Typescript can't infer if groups is empty visibleRecordIds must be populated\n            // but the extra safety isn't bad. (istanbul also can't ignore just the ??)\n            // istanbul ignore next\n            return this._data.groupData.visibleRecordIds ?? [];\n        }\n\n        // Otherwise build the recordId's from children groups\n        let recordIds: Array<RecordId> = [];\n        for (const group of this.groups) {\n            recordIds.push(...group.recordIds);\n        }\n        return recordIds;\n    }\n\n    /**\n     * Anytime the recordIds to return could have changed, we clear this so that\n     * the next time the user requests recordIds it recomputes\n     *\n     * @internal\n     */\n    _invalidateComputedRecordIds(): void {\n        this._orderedRecordIds = null;\n    }\n\n    /**\n     * Ordered array of all the record ids inside this group, in group order.\n     * This returns all recordIds of all children groups (in grouped order).\n     * Watchable.\n     */\n    get recordIds(): ReadonlyArray<RecordId> {\n        invariant(this.isDataLoaded, 'GroupedRecordQueryResult data is not loaded');\n\n        if (this._orderedRecordIds === null) {\n            this._orderedRecordIds = this._computeRecordIds();\n        }\n\n        return this._orderedRecordIds;\n    }\n\n    /**\n     * The fields that were used to create the parent RecordQueryResult that created this GroupedRecordQueryResult.\n     * This is separate from the field/fieldId property - which is the field this grouping is based upon.\n     * Null if fields were not specified, which means the RecordQueryResult\n     * will load all fields in the table.\n     */\n    get fields(): Array<Field> | null {\n        invariant(this.isDataLoaded, 'GroupedRecordQueryResult data is not loaded');\n        return this._parentQueryResult.fields;\n    }\n\n    /** @inheritdoc */\n    watch(\n        keys: WatchableRecordQueryResultKey | ReadonlyArray<WatchableRecordQueryResultKey>,\n        callback: FlowAnyFunction,\n        context?: FlowAnyObject | null,\n    ): Array<WatchableRecordQueryResultKey> {\n        // TODO (SeanKeenan): This provides events even if they occur outside of this group\n        // This is an issue that needs to be fixed before this API is made public\n        const validKeys = this._parentQueryResult.watch(keys, callback, context);\n        return validKeys;\n    }\n\n    /** @inheritdoc */\n    unwatch(\n        keys: WatchableRecordQueryResultKey | ReadonlyArray<WatchableRecordQueryResultKey>,\n        callback: FlowAnyFunction,\n        context?: FlowAnyObject | null,\n    ): Array<WatchableRecordQueryResultKey> {\n        return this._parentQueryResult.unwatch(keys, callback, context);\n    }\n\n    /** @inheritdoc */\n    async loadDataAsync(): Promise<void> {\n        await super.loadDataAsync();\n    }\n\n    /** @internal */\n    _getChangedKeysOnLoad(): Array<WatchableRecordQueryResultKey> {\n        return this._parentQueryResult._getChangedKeysOnLoad();\n    }\n\n    /** @internal */\n    async _loadDataAsync(): Promise<Array<WatchableRecordQueryResultKey>> {\n        // TODO: This entire class assumes it is torn down and re-created by the parent whenever\n        // a change to the group is made.\n        this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this);\n        return this._getChangedKeysOnLoad();\n    }\n\n    /** @internal */\n    _unloadData() {\n        // Invalidate both of the caches, as this object can no longer be accessed\n        this._invalidateComputedRecordIds();\n        this._invalidateRecordIdsSet();\n\n        this._unloadChildrenGroupsIfNeeded();\n        this._parentQueryResult.__groupedRecordQueryResultPool.unregisterObjectForReuseStrong(this);\n    }\n\n    /** @internal */\n    get __poolKey() {\n        // TODO (SeanKeenan) We don't have an actual groupId, but while id is unique; this should have id removed\n        return `${this._serializedOpts}::${this.id}`;\n    }\n\n    /**\n     * This model doesn't actually load data, but it does use the `_data`\n     * property so that checks for model deletion behave appropriately.\n     *\n     * This is considered deleted if the parent query result has been deleted.\n     *\n     * We return groupData, instead of precomputing all children groups because\n     * we perform the computation+caching lazily on request\n     *\n     * @internal\n     */\n    get _dataOrNullIfDeleted(): GroupedRecordQueryResultData | null {\n        if (this._parentQueryResult._dataOrNullIfDeleted === null) {\n            return null;\n        }\n        return {\n            groupData: this._groupData,\n            groupLevels: this._groupLevels,\n        };\n    }\n\n    /** @inheritdoc */\n    get isDataLoaded(): boolean {\n        return this._parentQueryResult.isDataLoaded;\n    }\n\n    /** @internal */\n    _unloadChildrenGroupsIfNeeded() {\n        if (this._orderedChildrenGroups) {\n            for (const group of this._orderedChildrenGroups) {\n                group.unloadData();\n            }\n        }\n    }\n\n    /** @internal */\n    _invalidateRecordIdsSet() {\n        this._recordIdsSet = null;\n    }\n\n    /** @internal */\n    _getOrGenerateRecordIdsSet() {\n        // TODO (SeanKeenan): this logic is duplicated in tableOrViewQueryResult\n        if (!this._recordIdsSet) {\n            const recordIdsSet: ObjectMap<RecordId, true> = {};\n            for (const recordId of this.recordIds) {\n                recordIdsSet[recordId] = true;\n            }\n            this._recordIdsSet = recordIdsSet;\n        }\n\n        return this._recordIdsSet;\n    }\n}\n\nexport default GroupedRecordQueryResult;\n"]}