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

package/dist/cjs/testing/abstract_mock_airtable_interface.js

@@ -0,0 +1,367 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.array.concat");
+
+require("core-js/modules/es.array.iterator");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractMockAirtableInterface = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+require("regenerator-runtime/runtime");
+
+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 _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _private_utils = require("../private_utils");
+
+var _error_utils = require("../error_utils");
+
+// istanbul ignore file
+var EventEmitter = require('events');
+/** @internal */
+
+
+var aggregators = {
+  aggregate(appInterface, summaryFunctionKey, cellValues, fieldData) {
+    return null;
+  },
+
+  aggregateToString(appInterface, summaryFunctionKey, cellValues, fieldData) {
+    return '';
+  },
+
+  getAggregatorConfig(summaryFunctionKey) {
+    return {
+      key: '',
+      displayName: '',
+      shortDisplayName: ''
+    };
+  },
+
+  getAllAvailableAggregatorKeys() {
+    return [];
+  },
+
+  getAvailableAggregatorKeysForField(fieldData) {
+    return [];
+  }
+
+};
+/** @internal */
+
+var fieldTypeProvider = {
+  isComputed(fieldData) {
+    return false;
+  },
+
+  validateConfigForUpdate: () => {
+    return {
+      isValid: true
+    };
+  },
+  getConfig: (appInterface, fieldData, fieldNamesById) => {
+    return {
+      type: fieldData.type,
+      options: fieldData.typeOptions
+    };
+  },
+  canBePrimary: () => {
+    return true;
+  },
+
+  convertStringToCellValue(appInterface, string, fieldData) {
+    return '';
+  },
+
+  convertCellValueToString(appInterface, cellValue, fieldData) {
+    return '';
+  },
+
+  getCellRendererData(appInterface, cellValue, fieldData, shouldWrap) {
+    return {
+      cellValueHtml: "<pre>".concat(JSON.stringify(cellValue), "</pre>"),
+      attributes: {}
+    };
+  },
+
+  validateCellValueForUpdate(appInterface, newCellValue, currentCellValue, fieldData) {
+    return {
+      isValid: true
+    };
+  },
+
+  getUiConfig(appInterface, fieldData) {
+    return {
+      iconName: '',
+      desiredCellWidthForRecordCard: 0,
+      minimumCellWidthForRecordCard: 0
+    };
+  }
+
+};
+/** @internal */
+
+var urlConstructor = {
+  getTableUrl(tableId) {
+    return "https://airtable.test/".concat(tableId);
+  },
+
+  getViewUrl(viewId, tableId) {
+    return "https://airtable.test/".concat(tableId, "/").concat(viewId);
+  },
+
+  getRecordUrl(recordId, tableId) {
+    return "https://airtable.test/".concat(tableId, "/").concat(recordId);
+  },
+
+  getAttachmentClientUrl(appInterface, attachmentId, attachmentUrl) {
+    return attachmentUrl;
+  }
+
+};
+/** @internal */
+
+var globalConfigHelpers = {
+  validatePath(path, store) {
+    return {
+      isValid: true
+    };
+  },
+
+  validateAndApplyUpdates(updates, store) {
+    throw (0, _error_utils.spawnError)('validateAndApplyUpdates unimplemented');
+  }
+
+};
+/** @internal */
+
+var idGenerator = {
+  generateRecordId: () => 'recGeneratedMockId',
+  generateFieldId: () => 'fldGeneratedMockId',
+  generateTableId: () => 'tblGeneratedMockId'
+};
+/**
+ * An abstract base class with a common interface exposed to both Blocks SDK's
+ * internal automated test suite and the blocks-testing public repo.
+ *
+ * @hidden
+ */
+
+var AbstractMockAirtableInterface =
+/*#__PURE__*/
+function (_EventEmitter) {
+  (0, _inherits2.default)(AbstractMockAirtableInterface, _EventEmitter);
+
+  function AbstractMockAirtableInterface(initData) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, AbstractMockAirtableInterface);
+    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AbstractMockAirtableInterface).call(this));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "sdkInitData", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_initData", void 0);
+    _this._initData = (0, _private_utils.cloneDeep)(initData);
+
+    _this.reset();
+
+    return _this;
+  }
+  /**
+   * Revert the mock interface to its initial state. This includes:
+   *
+   * - removing all event listeners
+   * - restoring the database schema
+   */
+
+
+  (0, _createClass2.default)(AbstractMockAirtableInterface, [{
+    key: "reset",
+    value: function reset() {
+      this.removeAllListeners();
+      this.sdkInitData = (0, _private_utils.cloneDeep)(this._initData);
+    } // The following properties are defined using accessors in order to
+    // facilitate overriding in subclasses.
+
+  }, {
+    key: "assertAllowedSdkPackageVersion",
+    value: function assertAllowedSdkPackageVersion() {}
+  }, {
+    key: "applyMutationAsync",
+    value: function applyMutationAsync(mutation, opts) {
+      return Promise.resolve();
+    }
+  }, {
+    key: "checkPermissionsForMutation",
+    value: function checkPermissionsForMutation(mutation) {
+      return {
+        hasPermission: true
+      };
+    }
+  }, {
+    key: "createVisListWithRecordIds",
+    value: function createVisListWithRecordIds(recordIds, fieldDatas, sorts, tableId) {
+      return {
+        removeRecordIds(removedRecordIds) {},
+
+        addRecordIds(addedRecordIds) {},
+
+        getOrderedRecordIds() {
+          return [...recordIds];
+        }
+
+      };
+    }
+  }, {
+    key: "subscribeToModelUpdates",
+    value: function subscribeToModelUpdates(fn) {
+      this.on('modelupdates', fn);
+    }
+  }, {
+    key: "setActiveViewOrTable",
+    value: function setActiveViewOrTable(tableId, viewId) {}
+  }, {
+    key: "subscribeToQueryAndPopulateStoresAsync",
+    value: function subscribeToQueryAndPopulateStoresAsync(query, options) {
+      return _regenerator.default.async(function subscribeToQueryAndPopulateStoresAsync$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)('subscribeToQueryAndPopulateStoresAsync unimplemented');
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      });
+    }
+  }, {
+    key: "unsubscribeFromQueryIdsAsync",
+    value: function unsubscribeFromQueryIdsAsync(querySpecIds) {
+      return _regenerator.default.async(function unsubscribeFromQueryIdsAsync$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)('unsubscribeFromQueryIdsAsync unimplemented');
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      });
+    }
+  }, {
+    key: "getTableRecordStoreIfExists",
+    value: function getTableRecordStoreIfExists(tableId) {
+      throw (0, _error_utils.spawnError)('getTableRecordStoreIfExists unimplemented');
+    }
+  }, {
+    key: "getViewMetadataStoreIfExists",
+    value: function getViewMetadataStoreIfExists(tableId, viewId) {
+      throw (0, _error_utils.spawnError)('getViewMetadataStoreIfExists unimplemented');
+    } // TODO(jugglinmike): Implement
+
+  }, {
+    key: "subscribeToGlobalConfigUpdates",
+    value: function subscribeToGlobalConfigUpdates() {}
+  }, {
+    key: "subscribeToSettingsButtonClick",
+    value: function subscribeToSettingsButtonClick() {}
+  }, {
+    key: "subscribeToEnterFullScreen",
+    value: function subscribeToEnterFullScreen() {}
+  }, {
+    key: "subscribeToExitFullScreen",
+    value: function subscribeToExitFullScreen() {}
+  }, {
+    key: "subscribeToFocus",
+    value: function subscribeToFocus() {}
+  }, {
+    key: "triggerModelUpdates",
+    value: function triggerModelUpdates(changes) {
+      this.emit('modelupdates', {
+        changes
+      });
+    } // TODO(jugglinmike): Implement
+
+  }, {
+    key: "triggerGlobalConfigUpdates",
+    value: function triggerGlobalConfigUpdates() {}
+  }, {
+    key: "triggerSettingsButtonClick",
+    value: function triggerSettingsButtonClick() {}
+  }, {
+    key: "triggerEnterFullScreen",
+    value: function triggerEnterFullScreen() {}
+  }, {
+    key: "triggerExitFullScreen",
+    value: function triggerExitFullScreen() {}
+  }, {
+    key: "triggerFocus",
+    value: function triggerFocus() {}
+  }, {
+    key: "unsubscribeFromCursorData",
+    value: function unsubscribeFromCursorData() {}
+  }, {
+    key: "unsubscribeFromTableData",
+    value: function unsubscribeFromTableData() {}
+  }, {
+    key: "unsubscribeFromCellValuesInFields",
+    value: function unsubscribeFromCellValuesInFields() {}
+  }, {
+    key: "unsubscribeFromViewData",
+    value: function unsubscribeFromViewData() {}
+  }, {
+    key: "aggregators",
+    get: function get() {
+      return aggregators;
+    }
+  }, {
+    key: "fieldTypeProvider",
+    get: function get() {
+      return fieldTypeProvider;
+    }
+  }, {
+    key: "urlConstructor",
+    get: function get() {
+      return urlConstructor;
+    }
+  }, {
+    key: "globalConfigHelpers",
+    get: function get() {
+      return globalConfigHelpers;
+    }
+  }, {
+    key: "idGenerator",
+    get: function get() {
+      return idGenerator;
+    }
+  }]);
+  return AbstractMockAirtableInterface;
+}(EventEmitter);
+
+exports.AbstractMockAirtableInterface = AbstractMockAirtableInterface;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/testing/abstract_mock_airtable_interface.ts"],"names":["EventEmitter","require","aggregators","aggregate","appInterface","summaryFunctionKey","cellValues","fieldData","aggregateToString","getAggregatorConfig","key","displayName","shortDisplayName","getAllAvailableAggregatorKeys","getAvailableAggregatorKeysForField","fieldTypeProvider","isComputed","validateConfigForUpdate","isValid","getConfig","fieldNamesById","type","options","typeOptions","canBePrimary","convertStringToCellValue","string","convertCellValueToString","cellValue","getCellRendererData","shouldWrap","cellValueHtml","JSON","stringify","attributes","validateCellValueForUpdate","newCellValue","currentCellValue","getUiConfig","iconName","desiredCellWidthForRecordCard","minimumCellWidthForRecordCard","urlConstructor","getTableUrl","tableId","getViewUrl","viewId","getRecordUrl","recordId","getAttachmentClientUrl","attachmentId","attachmentUrl","globalConfigHelpers","validatePath","path","store","validateAndApplyUpdates","updates","idGenerator","generateRecordId","generateFieldId","generateTableId","AbstractMockAirtableInterface","initData","_initData","reset","removeAllListeners","sdkInitData","mutation","opts","Promise","resolve","hasPermission","recordIds","fieldDatas","sorts","removeRecordIds","removedRecordIds","addRecordIds","addedRecordIds","getOrderedRecordIds","fn","on","query","querySpecIds","changes","emit"],"mappings":"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","sourcesContent":["// istanbul ignore file\nimport {AggregatorKey} from '../types/aggregators';\nimport {\n    AggregatorConfig,\n    Aggregators,\n    AirtableInterface,\n    AppInterface,\n    BlockQuerySubscriptionOptions,\n    FieldTypeConfig,\n    FieldTypeProvider,\n    SdkInitData,\n    UrlConstructor,\n    GlobalConfigHelpers,\n    RecordStoreForTable,\n    ViewStore,\n    IdGenerator,\n    VisList,\n} from '../types/airtable_interface';\nimport {cloneDeep, ObjectMap} from '../private_utils';\nimport {spawnError} from '../error_utils';\nimport {FieldData, FieldId} from '../types/field';\nimport {ModelChange} from '../types/base';\nimport {RecordId} from '../types/record';\nimport {TableId} from '../types/table';\nimport {ViewId} from '../types/view';\nimport {ViewportSizeConstraint} from '../types/viewport';\nimport {Mutation, PermissionCheckResult} from '../types/mutations';\nimport {NormalizedSortConfig} from '../models/record_query_result';\nimport {RequestJson, ResponseJson} from '../types/backend_fetch_types';\nimport {CursorData} from '../types/cursor';\nimport {RecordActionData} from '../types/record_action_data';\nimport {BlockQueryId, BlockQuerySpec, QuerySpecsResponse} from '../types/block_query_spec';\nconst EventEmitter = require('events');\n\n/** @internal */\nconst aggregators: Aggregators = {\n    aggregate(\n        appInterface: AppInterface,\n        summaryFunctionKey: AggregatorKey,\n        cellValues: Array<unknown>,\n        fieldData: FieldData,\n    ): unknown {\n        return null;\n    },\n    aggregateToString(\n        appInterface: AppInterface,\n        summaryFunctionKey: AggregatorKey,\n        cellValues: Array<unknown>,\n        fieldData: FieldData,\n    ): string {\n        return '';\n    },\n    getAggregatorConfig(summaryFunctionKey: AggregatorKey): AggregatorConfig {\n        return {\n            key: '',\n            displayName: '',\n            shortDisplayName: '',\n        };\n    },\n    getAllAvailableAggregatorKeys(): Array<AggregatorKey> {\n        return [];\n    },\n    getAvailableAggregatorKeysForField(fieldData: FieldData): Array<AggregatorKey> {\n        return [];\n    },\n};\n\n/** @internal */\nconst fieldTypeProvider: FieldTypeProvider = {\n    isComputed(fieldData: FieldData) {\n        return false;\n    },\n    validateConfigForUpdate: () => {\n        return {isValid: true};\n    },\n    getConfig: (\n        appInterface: AppInterface,\n        fieldData: FieldData,\n        fieldNamesById: ObjectMap<FieldId, string>,\n    ) => {\n        return {\n            type: fieldData.type,\n            options: fieldData.typeOptions,\n        } as FieldTypeConfig;\n    },\n    canBePrimary: () => {\n        return true;\n    },\n    convertStringToCellValue(appInterface: AppInterface, string: string, fieldData: FieldData) {\n        return '';\n    },\n    convertCellValueToString(appInterface: AppInterface, cellValue: unknown, fieldData: FieldData) {\n        return '';\n    },\n    getCellRendererData(\n        appInterface: AppInterface,\n        cellValue: unknown,\n        fieldData: FieldData,\n        shouldWrap: boolean,\n    ) {\n        return {cellValueHtml: `<pre>${JSON.stringify(cellValue)}</pre>`, attributes: {}};\n    },\n    validateCellValueForUpdate(\n        appInterface: AppInterface,\n        newCellValue: unknown,\n        currentCellValue: unknown,\n        fieldData: FieldData,\n    ) {\n        return {isValid: true};\n    },\n    getUiConfig(appInterface: AppInterface, fieldData: FieldData) {\n        return {\n            iconName: '',\n            desiredCellWidthForRecordCard: 0,\n            minimumCellWidthForRecordCard: 0,\n        };\n    },\n};\n\n/** @internal */\nconst urlConstructor: UrlConstructor = {\n    getTableUrl(tableId) {\n        return `https://airtable.test/${tableId}`;\n    },\n    getViewUrl(viewId, tableId) {\n        return `https://airtable.test/${tableId}/${viewId}`;\n    },\n    getRecordUrl(recordId, tableId) {\n        return `https://airtable.test/${tableId}/${recordId}`;\n    },\n    getAttachmentClientUrl(appInterface, attachmentId, attachmentUrl) {\n        return attachmentUrl;\n    },\n};\n\n/** @internal */\nconst globalConfigHelpers: GlobalConfigHelpers = {\n    validatePath(path, store) {\n        return {isValid: true};\n    },\n    validateAndApplyUpdates(updates, store) {\n        throw spawnError('validateAndApplyUpdates unimplemented');\n    },\n};\n\n/** @internal */\nconst idGenerator: IdGenerator = {\n    generateRecordId: () => 'recGeneratedMockId',\n    generateFieldId: () => 'fldGeneratedMockId',\n    generateTableId: () => 'tblGeneratedMockId',\n};\n\n/**\n * An abstract base class with a common interface exposed to both Blocks SDK's\n * internal automated test suite and the blocks-testing public repo.\n *\n * @hidden\n */\nexport abstract class AbstractMockAirtableInterface extends EventEmitter\n    implements AirtableInterface {\n    sdkInitData!: SdkInitData;\n\n    private _initData: SdkInitData;\n\n    constructor(initData: SdkInitData) {\n        super();\n        this._initData = cloneDeep(initData);\n        this.reset();\n    }\n\n    /**\n     * Revert the mock interface to its initial state. This includes:\n     *\n     * - removing all event listeners\n     * - restoring the database schema\n     */\n    reset() {\n        this.removeAllListeners();\n        this.sdkInitData = cloneDeep(this._initData);\n    }\n\n    // The following properties are defined using accessors in order to\n    // facilitate overriding in subclasses.\n    get aggregators() {\n        return aggregators;\n    }\n\n    get fieldTypeProvider() {\n        return fieldTypeProvider;\n    }\n\n    get urlConstructor() {\n        return urlConstructor;\n    }\n\n    get globalConfigHelpers() {\n        return globalConfigHelpers;\n    }\n\n    get idGenerator() {\n        return idGenerator;\n    }\n\n    assertAllowedSdkPackageVersion() {}\n\n    applyMutationAsync(mutation: Mutation, opts?: {holdForMs?: number}): Promise<void> {\n        return Promise.resolve();\n    }\n\n    checkPermissionsForMutation(mutation: Mutation): PermissionCheckResult {\n        return {\n            hasPermission: true,\n        };\n    }\n\n    createVisListWithRecordIds(\n        recordIds: ReadonlyArray<RecordId>,\n        fieldDatas: ReadonlyArray<FieldData>,\n        sorts: ReadonlyArray<NormalizedSortConfig>,\n        tableId: TableId,\n    ): VisList {\n        return {\n            removeRecordIds(removedRecordIds: Array<RecordId>) {},\n            addRecordIds(addedRecordIds: ReadonlyArray<RecordId>) {},\n            getOrderedRecordIds() {\n                return [...recordIds];\n            },\n        };\n    }\n\n    subscribeToModelUpdates(fn: Function) {\n        this.on('modelupdates', fn);\n    }\n\n    setActiveViewOrTable(tableId: TableId, viewId: ViewId) {}\n\n    async subscribeToQueryAndPopulateStoresAsync(\n        query: BlockQuerySpec,\n        options: BlockQuerySubscriptionOptions,\n    ): Promise<QuerySpecsResponse> {\n        throw spawnError('subscribeToQueryAndPopulateStoresAsync unimplemented');\n    }\n    async unsubscribeFromQueryIdsAsync(\n        querySpecIds: Array<BlockQueryId>,\n    ): Promise<{status: boolean}> {\n        throw spawnError('unsubscribeFromQueryIdsAsync unimplemented');\n    }\n    getTableRecordStoreIfExists(tableId: TableId): RecordStoreForTable | null {\n        throw spawnError('getTableRecordStoreIfExists unimplemented');\n    }\n    getViewMetadataStoreIfExists(tableId: TableId, viewId: ViewId): ViewStore | null {\n        throw spawnError('getViewMetadataStoreIfExists unimplemented');\n    }\n\n    // TODO(jugglinmike): Implement\n    subscribeToGlobalConfigUpdates() {}\n    subscribeToSettingsButtonClick() {}\n    subscribeToEnterFullScreen() {}\n    subscribeToExitFullScreen() {}\n    subscribeToFocus() {}\n    abstract fetchAndSubscribeToCursorDataAsync(): Promise<CursorData>;\n    abstract fetchDefaultCellValuesByFieldIdAsync(): Promise<{[key: string]: unknown}>;\n\n    triggerModelUpdates(changes: ReadonlyArray<ModelChange>) {\n        this.emit('modelupdates', {changes});\n    }\n\n    // TODO(jugglinmike): Implement\n    triggerGlobalConfigUpdates() {}\n    triggerSettingsButtonClick() {}\n    triggerEnterFullScreen() {}\n    triggerExitFullScreen() {}\n    triggerFocus() {}\n\n    unsubscribeFromCursorData() {}\n    unsubscribeFromTableData() {}\n    unsubscribeFromCellValuesInFields() {}\n    unsubscribeFromViewData() {}\n\n    abstract expandRecord(tableId: string, recordId: string, recordIds: Array<string> | null): void;\n    abstract expandRecordList(\n        tableId: string,\n        recordIds: Array<string>,\n        fieldIds: Array<string> | null,\n    ): void;\n    abstract expandRecordPickerAsync(\n        tableId: string,\n        recordIds: Array<string>,\n        fieldIds: Array<string> | null,\n        shouldAllowCreatingRecord: boolean,\n    ): Promise<string | null>;\n    abstract reloadFrame(): void;\n    abstract setSettingsButtonVisibility(): void;\n    abstract setUndoRedoMode(): void;\n    abstract setFullscreenMaxSize(maxFullscreenSize: ViewportSizeConstraint): void;\n    abstract enterFullscreen(): void;\n    abstract exitFullscreen(): void;\n    abstract fetchAndSubscribeToPerformRecordActionAsync(): Promise<RecordActionData | null>;\n    abstract trackEvent(): void;\n    abstract trackExposure(): void;\n    abstract sendStat(): void;\n    abstract performBackendFetchAsync(requestJson: RequestJson): Promise<ResponseJson>;\n}\n"]}

package/dist/cjs/types/aggregators.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cjs/types/airtable_interface.js

@@ -16,4 +16,5 @@ exports.BlockRunContextType = BlockRunContextType;
 (function (BlockRunContextType) {
   BlockRunContextType["DASHBOARD_APP"] = "dashboardApp";
   BlockRunContextType["VIEW"] = "view";
-})(BlockRunContextType || (exports.BlockRunContextType = BlockRunContextType = {}));
+})(BlockRunContextType || (exports.BlockRunContextType = BlockRunContextType = {}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/types/airtable_interface.ts"],"names":["BlockRunContextType"],"mappings":";;;;;;AAyCA;AACA;;AACA;IACYA,mB;AAKZ;;;;WALYA,mB;AAAAA,EAAAA,mB;AAAAA,EAAAA,mB;GAAAA,mB,mCAAAA,mB","sourcesContent":["import {ObjectMap} from '../private_utils';\nimport {NormalizedSortConfig} from '../models/record_query_result';\nimport {Color} from '../colors';\nimport {Stat} from './stat';\nimport {AggregatorKey} from './aggregators';\nimport {BaseData, BasePermissionData, ModelChange} from './base';\nimport {BlockInstallationId} from './block';\nimport {CursorData} from './cursor';\nimport {FieldData, FieldId, FieldType} from './field';\nimport {RecordActionData, RecordActionDataCallback} from './record_action_data';\nimport {\n    GlobalConfigUpdate,\n    GlobalConfigData,\n    GlobalConfigPath,\n    GlobalConfigPathValidationResult,\n} from './global_config';\nimport {RecordId} from './record';\nimport {UndoRedoMode} from './undo_redo';\nimport {ViewportSizeConstraint} from './viewport';\nimport {\n    Mutation,\n    PartialMutation,\n    PermissionCheckResult,\n    UpdateFieldOptionsOpts,\n} from './mutations';\nimport {TableId} from './table';\nimport {\n    GroupData,\n    ViewColorsByRecordIdData,\n    ViewFieldOrderData,\n    ViewId,\n    GroupLevelData,\n} from './view';\nimport {RequestJson, ResponseJson} from './backend_fetch_types';\nimport {\n    BlockQuerySpec,\n    BlockQueryId,\n    QuerySpecsResponse,\n    BlockQuerySubscriptionOnChangeCallback,\n} from './block_query_spec';\n\n// BlockRunContextType, BlockInstallationPageBlockRunContext, ViewBlockRunContext, BlockRunContext\n// must be kept in sync with block_run_context.tsx in hyperbase repo\n/** @hidden */\nexport enum BlockRunContextType {\n    DASHBOARD_APP = 'dashboardApp',\n    VIEW = 'view',\n}\n\n/** @hidden */\nexport interface BlockInstallationPageBlockRunContext {\n    type: BlockRunContextType.DASHBOARD_APP;\n}\n\n/** @hidden */\nexport interface ViewBlockRunContext {\n    type: BlockRunContextType.VIEW;\n    tableId: TableId;\n    viewId: ViewId;\n}\n\n/** @hidden */\nexport type BlockRunContext = BlockInstallationPageBlockRunContext | ViewBlockRunContext;\n\n/** @hidden */\nexport interface PartialViewData {\n    visibleRecordIds: Array<string>;\n    fieldOrder: ViewFieldOrderData;\n    colorsByRecordId: ViewColorsByRecordIdData | null;\n    // Groups can be undefined if running against an old airtable client\n    groups?: Array<GroupData> | null;\n    groupLevels?: Array<GroupLevelData> | null;\n}\n\n// TODO: (SeanKeenan) Move NormalizedSortConfig from record_query_result here\n//       once/if we support setting the sort config for a view\n/** @hidden */\nexport type NormalizedGroupLevel = GroupLevelData;\n\n/** @hidden */\nexport interface NormalizedViewMetadata {\n    /** Group levels, can be null or unspecified (null to clear, unspecified to not overwrite) */\n    groupLevels?: Array<NormalizedGroupLevel> | null | undefined;\n}\n\n/** @hidden */\nexport interface SdkInitData {\n    initialKvValuesByKey: GlobalConfigData;\n    isDevelopmentMode: boolean;\n    baseData: BaseData;\n    blockInstallationId: BlockInstallationId;\n    // NOTE: these don't really make much sense in backend blocks.\n    // TODO: figure out what to do with them.\n    isFullscreen: boolean;\n    isFirstRun: boolean;\n    intentData: unknown;\n    isUsingNewLookupCellValueFormat?: true | undefined;\n    runContext: BlockRunContext;\n}\n\n/** @hidden */\nexport interface IdGenerator {\n    generateRecordId(): string;\n    generateFieldId(): string;\n    generateTableId(): string;\n}\n\n/** @hidden */\nexport interface UrlConstructor {\n    getTableUrl(tableId: TableId): string;\n    getViewUrl(viewId: ViewId, tableId: TableId): string;\n    getRecordUrl(recordId: RecordId, tableId: TableId): string;\n    getAttachmentClientUrl(\n        appInterface: AppInterface,\n        attachmentId: string,\n        attachmentUrl: string,\n    ): string;\n}\n\n/** @hidden */\nexport interface AggregatorConfig {\n    key: AggregatorKey;\n    displayName: string;\n    shortDisplayName: string;\n}\n\n/** @hidden */\nexport interface Aggregators {\n    aggregate(\n        appInterface: AppInterface,\n        summaryFunctionKey: AggregatorKey,\n        cellValues: Array<unknown>,\n        fieldData: FieldData,\n    ): unknown;\n    aggregateToString(\n        appInterface: AppInterface,\n        summaryFunctionKey: AggregatorKey,\n        cellValues: Array<unknown>,\n        fieldData: FieldData,\n    ): string;\n    getAggregatorConfig(summaryFunctionKey: AggregatorKey): AggregatorConfig;\n    getAllAvailableAggregatorKeys(): Array<AggregatorKey>;\n    getAvailableAggregatorKeysForField(fieldData: FieldData): Array<AggregatorKey>;\n}\n\n/** @hidden */\ntype CellValueValidationResult = {isValid: true} | {isValid: false; reason: string};\n/** @hidden */\ntype FieldConfigValidationResult = {isValid: true} | {isValid: false; reason: string};\n/** @hidden */\nexport interface FieldTypeConfig {\n    type: FieldType;\n    options?: {[key: string]: unknown};\n}\n/** @hidden */\ninterface FieldUiConfig {\n    iconName: string;\n    desiredCellWidthForRecordCard: number;\n    minimumCellWidthForRecordCard: number;\n}\n\n/** @hidden */\nexport interface FieldTypeProvider {\n    isComputed(fieldData: FieldData): boolean;\n    validateCellValueForUpdate(\n        appInterface: AppInterface,\n        newCellValue: unknown,\n        currentCellValue: unknown,\n        fieldData: FieldData,\n    ): CellValueValidationResult;\n    getConfig(\n        appInterface: AppInterface,\n        fieldData: FieldData,\n        fieldNamesById: ObjectMap<FieldId, string>,\n    ): FieldTypeConfig;\n    validateConfigForUpdate(\n        appInterface: AppInterface,\n        newConfig: FieldTypeConfig,\n        currentConfig: FieldTypeConfig | null,\n        fieldData: FieldData | null,\n        billingPlanGrouping: string,\n        opts?: UpdateFieldOptionsOpts,\n    ): FieldConfigValidationResult;\n    canBePrimary(\n        appInterface: AppInterface,\n        config: FieldTypeConfig,\n        billingPlanGrouping: string,\n    ): boolean;\n    convertStringToCellValue(\n        appInterface: AppInterface,\n        string: string,\n        fieldData: FieldData,\n    ): unknown;\n    convertCellValueToString(\n        appInterface: AppInterface,\n        cellValue: unknown,\n        fieldData: FieldData,\n    ): string;\n    getCellRendererData(\n        appInterface: AppInterface,\n        cellValue: unknown,\n        fieldData: FieldData,\n        shouldWrap: boolean,\n    ): {cellValueHtml: string; attributes: {[key: string]: unknown}};\n    getUiConfig: (appInterface: AppInterface, fieldData: FieldData) => FieldUiConfig;\n}\n\n/** @hidden */\nexport interface GlobalConfigHelpers {\n    validatePath(path: GlobalConfigPath, store: GlobalConfigData): GlobalConfigPathValidationResult;\n    validateAndApplyUpdates(\n        updates: ReadonlyArray<GlobalConfigUpdate>,\n        store: GlobalConfigData,\n    ): {\n        newKvStore: GlobalConfigData;\n        changedTopLevelKeys: Array<string>;\n    };\n}\n\n/**\n * AppInterface should never be used directly by the SDK, so we don't describe the type.\n *\n * @hidden\n */\nexport type AppInterface = unknown;\n\n/**\n * Keep this in sync with hyperbase repo's `BlockSdkVisList` definition\n *\n * @hidden\n */\nexport interface VisList {\n    removeRecordIds(recordIds: Array<RecordId>): void;\n    addRecordIds(recordIds: ReadonlyArray<RecordId>): void;\n    getOrderedRecordIds(): Array<RecordId>;\n}\n\n/**\n * Only loads data after a query executes the data\n *\n * @hidden\n */\nexport interface RecordStoreForTable {\n    getTableId(): TableId;\n\n    // May not be required?\n    getPartiallyLoadedRecordIds(): ReadonlyArray<RecordId>;\n\n    //\n    // Record scoped functions\n    //\n    isRecordPartiallyLoaded(recordId: RecordId): boolean;\n    isRecordDeleted(recordId: RecordId): boolean;\n    isRecordCellValueLoadedForFieldId(recordId: RecordId, fieldId: FieldId): boolean;\n\n    getRecordCellValueByFieldId(recordId: RecordId, fieldId: FieldId): unknown;\n    getRecordCommentCount(recordId: RecordId): number;\n    getRecordCreatedTime(recordId: RecordId): Date;\n}\n\n/**\n * Only loads data after a query executes the data\n *\n * @hidden\n */\nexport interface ViewStore {\n    getViewId(): ViewId;\n    getVisibleRecordIds(): ReadonlyArray<RecordId>;\n    getFieldOrder(): ViewFieldOrderData;\n    getGroups(): ReadonlyArray<GroupData> | null;\n    getGroupLevels(): ReadonlyArray<GroupLevelData> | null;\n    getColorForRecordId(recordId: RecordId): Color | null;\n}\n\n/** @hidden */\nexport interface BlockQuerySubscriptionOptions {\n    onChangeCallback?: BlockQuerySubscriptionOnChangeCallback;\n}\n\n/**\n * AirtableInterface is designed as the communication interface between the\n * Block SDK and Airtable. The mechanism through which we communicate with Airtable\n * depends on the context in which the block is running (i.e. frontend or backend),\n * but the interface should remain consistent.\n *\n * @hidden\n */\nexport interface AirtableInterface {\n    sdkInitData: SdkInitData;\n    idGenerator: IdGenerator;\n    urlConstructor: UrlConstructor;\n    aggregators: Aggregators;\n    fieldTypeProvider: FieldTypeProvider;\n    globalConfigHelpers: GlobalConfigHelpers;\n\n    // Subscribing / unsubscribing from queries\n    subscribeToQueryAndPopulateStoresAsync(\n        query: BlockQuerySpec,\n        options: BlockQuerySubscriptionOptions,\n    ): Promise<QuerySpecsResponse>;\n    unsubscribeFromQueryIdsAsync(querySpecIds: Array<BlockQueryId>): Promise<{status: boolean}>;\n\n    // Allows access to record cell values that have been subscribed using queries\n    getTableRecordStoreIfExists(tableId: TableId): RecordStoreForTable | null;\n    // Allows access to view data that has been subscribed using queries\n    getViewMetadataStoreIfExists(tableId: TableId, viewId: ViewId): ViewStore | null;\n\n    assertAllowedSdkPackageVersion: (packageName: string, packageVersion: string) => void;\n    fetchDefaultCellValuesByFieldIdAsync(\n        tableId: string,\n        viewId: string | null,\n    ): Promise<{[key: string]: unknown}>;\n\n    applyMutationAsync(mutation: Mutation, opts?: {holdForMs?: number}): Promise<void>;\n    checkPermissionsForMutation(\n        mutation: PartialMutation,\n        basePermissionData: BasePermissionData,\n    ): PermissionCheckResult;\n\n    // frontend only:\n    subscribeToModelUpdates(callback: (data: {changes: ReadonlyArray<ModelChange>}) => void): void;\n    subscribeToGlobalConfigUpdates(\n        callback: (data: {updates: ReadonlyArray<GlobalConfigUpdate>}) => void,\n    ): void;\n    subscribeToSettingsButtonClick(callback: () => void): void;\n    subscribeToEnterFullScreen(callback: () => void): void;\n    subscribeToExitFullScreen(callback: () => void): void;\n    subscribeToFocus(callback: () => void): void;\n    fetchAndSubscribeToCursorDataAsync(): Promise<CursorData>;\n    unsubscribeFromCursorData(): void;\n    expandRecord(tableId: string, recordId: string, recordIds: Array<string> | null): void;\n    expandRecordList(\n        tableId: string,\n        recordIds: Array<string>,\n        fieldIds: Array<string> | null,\n    ): void;\n    expandRecordPickerAsync(\n        tableId: string,\n        recordIds: Array<string>,\n        fieldIds: Array<string> | null,\n        shouldAllowCreatingRecord: boolean,\n    ): Promise<string | null>;\n    reloadFrame(): void;\n    setSettingsButtonVisibility(isVisible: boolean): void;\n    setUndoRedoMode(mode: UndoRedoMode): void;\n    setFullscreenMaxSize(maxFullscreenSize: ViewportSizeConstraint): void;\n    enterFullscreen(): void;\n    exitFullscreen(): void;\n    createVisListWithRecordIds(\n        recordIds: ReadonlyArray<RecordId>,\n        fieldDatas: ReadonlyArray<FieldData>,\n        sorts: ReadonlyArray<NormalizedSortConfig>,\n        tableId: TableId,\n    ): VisList;\n    setActiveViewOrTable(tableId: TableId, viewId?: ViewId): void;\n    fetchAndSubscribeToPerformRecordActionAsync(\n        callback: RecordActionDataCallback,\n    ): Promise<RecordActionData | null>;\n    performBackendFetchAsync(requestJson: RequestJson): Promise<ResponseJson>;\n\n    /**\n     * internal utils\n     */\n    trackEvent(eventSchemaName: string, eventData: {[key: string]: unknown}): void;\n    trackExposure(featureName: string): void;\n    sendStat(stat: Stat): void;\n}\n"]}

package/dist/cjs/types/attachment.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cjs/types/backend_fetch_types.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cjs/types/base.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cjs/types/block.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cjs/types/block_query_spec.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BlockQuerySubscriptionChangeType = exports.BlockFieldSelectionSpecType = exports.BlockQuerySourceType = void 0;
+
+/**
+ * Specification for data needed by both the Blocks SDK and the blocks iframe
+ * that spans across a few repos and run environments:
+ * +--------------------+--------------------+--------------------+
+ * | airtable.com       | blocks iframe      | blocks sdk         |
+ * +--------------------+--------------------+--------------------+
+ * | repo: hyperbase    | repo: hyperbase    | repo: blocks-sdk   |
+ * | run: airtable.com  | run: iframe        | run: iframe        |
+ * +--------------------+--------------------+--------------------+
+ *
+ * A BlockQuerySpec has a required `source` and one or more `selection`s.
+ * The `source` is a top-level concept that defines where the data comes
+ * from, while the `selection`s define desired properties from the data.
+ * In other words, think of the data as a tree, the `source` defines the
+ * root, and the `selection`s define the branches and leaves.
+ *
+ * Note that instead of a sub-object `source`, we use `source`-prefixed
+ * properties for the same effect. This works around a TypeScript limitation
+ * of not being able to discriminate between the unions for BlockQuerySpec.
+ *
+ * The specification will be used for two parts of the data lifecycle:
+ * 1. An initial response, via BlockQuerySpecResponseForAirtableInterface
+ * 2. Subsequent updates to keep the date updated, via BlockQueryUpdate
+ *
+ * NOTE: Keep this in sync with the hyperbase repo's block_query_spec.tsx file!
+ *
+ * @hidden
+ */
+
+/** @hidden */
+
+/** @hidden */
+
+/** @hidden */
+var BlockQuerySourceType;
+/** @hidden */
+
+exports.BlockQuerySourceType = BlockQuerySourceType;
+
+(function (BlockQuerySourceType) {
+  BlockQuerySourceType["TABLE"] = "table";
+  BlockQuerySourceType["VIEW"] = "view";
+})(BlockQuerySourceType || (exports.BlockQuerySourceType = BlockQuerySourceType = {}));
+
+/**
+ * The different ways fields can be queried
+ *
+ * @hidden
+ */
+var BlockFieldSelectionSpecType;
+/**
+ * Allows querying for all fields, or a specified set of fields. In the latter
+ * case, we also allow specifying properties of a record like commentCount and
+ * recordCreatedTime that don't have fieldIds (ALL_FIELDS implies including all
+ * of these properties).
+ *
+ * @hidden
+ */
+
+exports.BlockFieldSelectionSpecType = BlockFieldSelectionSpecType;
+
+(function (BlockFieldSelectionSpecType) {
+  BlockFieldSelectionSpecType["SPECIFIED_FIELDS"] = "specifiedFields";
+  BlockFieldSelectionSpecType["ALL_FIELDS_FROM_TABLE"] = "allFieldsFromTable";
+})(BlockFieldSelectionSpecType || (exports.BlockFieldSelectionSpecType = BlockFieldSelectionSpecType = {}));
+
+/** @hidden */
+var BlockQuerySubscriptionChangeType;
+/** @hidden */
+
+exports.BlockQuerySubscriptionChangeType = BlockQuerySubscriptionChangeType;
+
+(function (BlockQuerySubscriptionChangeType) {
+  BlockQuerySubscriptionChangeType["ADDED_RECORD_IDS"] = "addedRecordIds";
+  BlockQuerySubscriptionChangeType["REMOVED_RECORD_IDS"] = "removedRecordIds";
+  BlockQuerySubscriptionChangeType["MODIFIED_CELL_VALUES_FOR_TABLE"] = "modifiedCellValuesForTable";
+  BlockQuerySubscriptionChangeType["CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW"] = "changedColorsByRecordIdForView";
+})(BlockQuerySubscriptionChangeType || (exports.BlockQuerySubscriptionChangeType = BlockQuerySubscriptionChangeType = {}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/types/block_query_spec.ts"],"names":["BlockQuerySourceType","BlockFieldSelectionSpecType","BlockQuerySubscriptionChangeType"],"mappings":";;;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA;;AAMA;;AAQA;IACYA,oB;AAKZ;;;;WALYA,oB;AAAAA,EAAAA,oB;AAAAA,EAAAA,oB;GAAAA,oB,oCAAAA,oB;;AAcZ;;;;;IAKYC,2B;AAKZ;;;;;;;;;;;WALYA,2B;AAAAA,EAAAA,2B;AAAAA,EAAAA,2B;GAAAA,2B,2CAAAA,2B;;AA+DZ;IACYC,gC;AAOZ;;;;WAPYA,gC;AAAAA,EAAAA,gC;AAAAA,EAAAA,gC;AAAAA,EAAAA,gC;AAAAA,EAAAA,gC;GAAAA,gC,gDAAAA,gC","sourcesContent":["import {ObjectMap} from '../private_utils';\nimport {TableId} from './table';\nimport {ViewId} from './view';\nimport {RecordId} from './record';\nimport {FieldId} from './field';\n\n/**\n * Specification for data needed by both the Blocks SDK and the blocks iframe\n * that spans across a few repos and run environments:\n * +--------------------+--------------------+--------------------+\n * | airtable.com       | blocks iframe      | blocks sdk         |\n * +--------------------+--------------------+--------------------+\n * | repo: hyperbase    | repo: hyperbase    | repo: blocks-sdk   |\n * | run: airtable.com  | run: iframe        | run: iframe        |\n * +--------------------+--------------------+--------------------+\n *\n * A BlockQuerySpec has a required `source` and one or more `selection`s.\n * The `source` is a top-level concept that defines where the data comes\n * from, while the `selection`s define desired properties from the data.\n * In other words, think of the data as a tree, the `source` defines the\n * root, and the `selection`s define the branches and leaves.\n *\n * Note that instead of a sub-object `source`, we use `source`-prefixed\n * properties for the same effect. This works around a TypeScript limitation\n * of not being able to discriminate between the unions for BlockQuerySpec.\n *\n * The specification will be used for two parts of the data lifecycle:\n * 1. An initial response, via BlockQuerySpecResponseForAirtableInterface\n * 2. Subsequent updates to keep the date updated, via BlockQueryUpdate\n *\n * NOTE: Keep this in sync with the hyperbase repo's block_query_spec.tsx file!\n *\n * @hidden\n */\nexport type BlockQuerySpec = BlockTableQuerySpec | BlockViewQuerySpec;\n/** @hidden */\nexport interface BlockTableQuerySpec {\n    sourceType: BlockQuerySourceType.TABLE;\n    sourceTableId: TableId;\n    recordSelection: BlockRecordSelectionSpec;\n}\n/** @hidden */\nexport interface BlockViewQuerySpec {\n    sourceType: BlockQuerySourceType.VIEW;\n    sourceTableId: TableId;\n    sourceViewId: ViewId;\n    recordSelection?: BlockRecordSelectionSpec;\n    viewMetadataSelection?: BlockViewMetadataSelectionSpec;\n}\n/** @hidden */\nexport enum BlockQuerySourceType {\n    TABLE = 'table',\n    VIEW = 'view',\n}\n\n/** @hidden */\nexport interface BlockRecordSelectionSpec {\n    readonly fieldSelection: BlockFieldSelectionSpec;\n    /** Optionally filter down to more specific recordIds from the source */\n    readonly recordIds?: Array<RecordId>;\n    // NOTE: please ensure that canonical_block_query_spec's\n    // canonicalizeRecordQuery is updated when new fields are added here\n}\n\n/**\n * The different ways fields can be queried\n *\n * @hidden\n */\nexport enum BlockFieldSelectionSpecType {\n    SPECIFIED_FIELDS = 'specifiedFields',\n    ALL_FIELDS_FROM_TABLE = 'allFieldsFromTable',\n}\n\n/**\n * Allows querying for all fields, or a specified set of fields. In the latter\n * case, we also allow specifying properties of a record like commentCount and\n * recordCreatedTime that don't have fieldIds (ALL_FIELDS implies including all\n * of these properties).\n *\n * @hidden\n */\nexport type BlockFieldSelectionSpec =\n    | {\n          readonly type: BlockFieldSelectionSpecType.SPECIFIED_FIELDS;\n          readonly fieldIds: Array<FieldId>;\n          // Section for fields not identified by fieldIds.\n          readonly shouldIncludeCommentCount?: boolean;\n          readonly shouldIncludeRecordCreatedTime?: boolean;\n      }\n    | {\n          readonly type: BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE;\n      };\n\n/** @hidden */\nexport interface BlockViewMetadataSelectionSpec {\n    // Undefined means default false, which is important when adding new opts\n    // but old SDKs don't provide them.\n    // These are extremely granular, but the server can always send more data\n    // than strictly subscribed to.\n    readonly shouldIncludeVisibleRecordIds?: boolean;\n    readonly shouldIncludeFieldOrder?: boolean;\n    readonly shouldIncludeGroups?: boolean;\n    readonly shouldIncludeGroupingLevels?: boolean;\n    readonly shouldIncludeColorsForRecordId?: boolean;\n}\n\n/**\n * Response recieved from an executed query.\n *\n * @hidden\n */\nexport type QuerySpecsResponse =\n    | {\n          readonly success: true;\n          readonly blockQueryId: BlockQueryId;\n      }\n    | {\n          readonly success: false;\n      };\n\n/**\n * An id returned from airtable for an active and executing query. If two queries sent\n * to airtable return the same queryId this means the queries are semantically the same.\n * It is however possible for two canonically identical queries to be tracked via two\n * separate blockQueryIds (in the case realtime subscriptions are made with different\n * callbacks).\n *\n * @hidden\n */\nexport type BlockQueryId = string;\n\n/** @hidden */\nexport enum BlockQuerySubscriptionChangeType {\n    ADDED_RECORD_IDS = 'addedRecordIds',\n    REMOVED_RECORD_IDS = 'removedRecordIds',\n    MODIFIED_CELL_VALUES_FOR_TABLE = 'modifiedCellValuesForTable',\n    CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW = 'changedColorsByRecordIdForView',\n}\n\n/** @hidden */\nexport type BlockQuerySubscriptionChange =\n    | {\n          // This represents removed or added records _in the scope of the query_\n          // So for a view filtered query, a REMOVED_RECORD_IDS means the record\n          // exited the view, or was filtered out.\n          type:\n              | BlockQuerySubscriptionChangeType.ADDED_RECORD_IDS\n              | BlockQuerySubscriptionChangeType.REMOVED_RECORD_IDS;\n          tableId: TableId;\n          recordIds: Array<RecordId>;\n      }\n    | {\n          // This just tracks which fields changed for which records - reading the value\n          // is required to determine what the new value is (potentially including \"deleted\")\n          type: BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE;\n          tableId: TableId;\n          fieldIdsByRecordId: ObjectMap<RecordId, Array<FieldId>>;\n          fieldIds: Array<FieldId>;\n      }\n    | {\n          type: BlockQuerySubscriptionChangeType.CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW;\n          tableId: TableId;\n          viewId: ViewId;\n          recordIds: Array<RecordId>;\n      };\n\n/** @hidden */\nexport type BlockQuerySubscriptionOnChangeCallback = (\n    changes: Array<BlockQuerySubscriptionChange>,\n) => void;\n"]}

package/dist/cjs/types/collaborator.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=

package/dist/cjs/types/cursor.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=