@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-3649c7162-20250904

package/dist/esm/base/models/view_metadata_query_result.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _error_utils = require("../../shared/error_utils");
+var _private_utils = require("../../shared/private_utils");
+var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module @airtable/blocks/models: View */ /** */
+
+const WatchableViewMetadataKeys = {
+  allFields: 'allFields',
+  visibleFields: 'visibleFields',
+  isDataLoaded: 'isDataLoaded',
+  groupLevels: 'groupLevels'
+};
+
+/**
+ * A key in {@link ViewMetadataQueryResult} that can be watched.
+ * - `allFields`
+ * - `visibleFields`
+ * - `isDataLoaded`
+ */
+
+/** @hidden */
+
+/**
+ * @hidden
+ */
+
+/**
+ * @hidden
+ */
+
+/**
+ * Contains information about a view that isn't loaded by default e.g. field order and visible fields.
+ *
+ * In a React component, we recommend using {@link useViewMetadata} instead.
+ *
+ * @example
+ * ```js
+ * async function loadMetadataForViewAsync(view) {
+ *     const viewMetadata = view.selectMetadata();
+ *     await viewMetadata.loadDataAsync();
+ *
+ *     console.log(viewMetadata.visibleFields);
+ *     // => [Field, Field, Field]
+ *
+ *     console.log(viewMetadata.allFields);
+ *     // => [Field, Field, Field, Field, Field]
+ *
+ *     viewMetadata.unloadData();
+ * }
+ * ```
+ * @docsPath models/query results/ViewMetadataQueryResult
+ */
+class ViewMetadataQueryResult extends _abstract_model_with_async_data.default {
+  /** @internal */
+  static _className = 'ViewMetadataQueryResult';
+
+  /** @internal */
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableViewMetadataKeys, key);
+  }
+
+  /** @internal */
+  static _shouldLoadDataForKey(key) {
+    return key === WatchableViewMetadataKeys.allFields || key === WatchableViewMetadataKeys.visibleFields || key === WatchableViewMetadataKeys.groupLevels;
+  }
+
+  /** */
+
+  /** @internal */
+
+  /** @internal */
+  constructor(sdk, parentView, viewDataStore) {
+    super(sdk, (0, _private_utils.getLocallyUniqueId)('ViewMetadataQueryResult'));
+    this.parentView = parentView;
+    this._viewDataStore = viewDataStore;
+  }
+
+  /** @internal */
+  get __poolKey() {
+    return this.parentView.id;
+  }
+
+  /** @internal */
+  get _dataOrNullIfDeleted() {
+    if (this._viewDataStore.isDeleted) {
+      return null;
+    }
+    if (!this._viewDataStore.isDataLoaded) {
+      return {
+        visibleFieldIds: null,
+        allFieldIds: null,
+        groupLevels: null
+      };
+    }
+    return {
+      visibleFieldIds: this._viewDataStore.visibleFieldIds,
+      allFieldIds: this._viewDataStore.allFieldIds,
+      groupLevels: this._viewDataStore.groupLevels
+    };
+  }
+
+  /** @internal */
+  _onChangeIsDataLoaded() {
+    this._onChange(WatchableViewMetadataKeys.isDataLoaded);
+  }
+
+  /** @internal */
+  async _loadDataAsync() {
+    await this._viewDataStore.loadDataAsync();
+    this._viewDataStore.watch('visibleFieldIds', this._onVisibleFieldIdsChange);
+    this._viewDataStore.watch('allFieldIds', this._onAllFieldIdsChange);
+    this._viewDataStore.watch('groupLevels', this._onGroupLevelsChange);
+    return [WatchableViewMetadataKeys.visibleFields, WatchableViewMetadataKeys.allFields, WatchableViewMetadataKeys.groupLevels];
+  }
+
+  /** @internal */
+  _unloadData() {
+    this._viewDataStore.unwatch('visibleFieldIds', this._onVisibleFieldIdsChange);
+    this._viewDataStore.unwatch('allFieldIds', this._onAllFieldIdsChange);
+    this._viewDataStore.unwatch('groupLevels', this._onGroupLevelsChange);
+    this._viewDataStore.unloadData();
+  }
+
+  /** @internal */
+  _onVisibleFieldIdsChange = () => {
+    this._onChange(WatchableViewMetadataKeys.visibleFields);
+  };
+
+  /** @internal */
+  _onAllFieldIdsChange = () => {
+    this._onChange(WatchableViewMetadataKeys.allFields);
+  };
+
+  /** @internal */
+  _onGroupLevelsChange = () => {
+    this._onChange(WatchableViewMetadataKeys.groupLevels);
+  };
+
+  /**
+   * Returns every field in the table in the order they appear in this view. Watchable.
+   */
+  get allFields() {
+    const allFieldIds = this._data.allFieldIds;
+    (0, _error_utils.invariant)(allFieldIds, 'view meta data is not loaded');
+    return allFieldIds.map(fieldId => this.parentView.parentTable.getFieldById(fieldId));
+  }
+
+  /**
+   * Returns every field visible in this view. Watchable.
+   */
+  get visibleFields() {
+    const visibleFieldIds = this._data.visibleFieldIds;
+    (0, _error_utils.invariant)(visibleFieldIds, 'view meta data is not loaded');
+    return visibleFieldIds.map(fieldId => this.parentView.parentTable.getFieldById(fieldId));
+  }
+
+  /**
+   * Returns group levels for this view. Watchable.
+   *
+   * @hidden
+   */
+  get groupLevels() {
+    const groupLevels = this._data.groupLevels;
+    return groupLevels ? groupLevels.map(singleConfig => ({
+      ...singleConfig,
+      field: this.parentView.parentTable.getFieldById(singleConfig.fieldId)
+    })) : null;
+  }
+}
+var _default = exports.default = ViewMetadataQueryResult;

package/dist/esm/base/perform_record_action.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatchablePerformRecordActionKeys = exports.PerformRecordAction = void 0;
+exports.__injectSdkIntoPerformRecordAction = __injectSdkIntoPerformRecordAction;
+exports.registerRecordActionDataCallback = registerRecordActionDataCallback;
+var _error_utils = require("../shared/error_utils");
+var _private_utils = require("../shared/private_utils");
+var _abstract_model_with_async_data = _interopRequireDefault(require("./models/abstract_model_with_async_data"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @hidden */
+const WatchablePerformRecordActionKeys = exports.WatchablePerformRecordActionKeys = Object.freeze({
+  // isDataLoaded must be a watchable key for a LoadableModel.
+  isDataLoaded: 'isDataLoaded',
+  recordActionData: 'recordActionData'
+});
+
+/** @hidden */
+
+/**
+ * Returned by {@link registerRecordActionDataCallback}. Call it to unregister the previously
+ * registered function. Do this before registering another function or unmounting the component.
+ * */
+
+/**
+ * This class exists to manage registering a callback to receive "Open block" / "Perform record
+ * action" messages.
+ * This is different to other message handlers (_registerHandlers) since the callback is specified
+ * by the block: it registers it during first render (vs the SDK registering during initialisation).
+ *
+ * On the liveapp side, we ensure that pending messages are held until the block registers the
+ * callback (or another message is sent). If there's a pending message, it is returned at
+ * registration.
+ *
+ * This class implements AbstractModelWithAsyncData in order to take advantage of useLoadable's
+ * suspense handling. "Loading" the model means registering the handler with liveapp. This allows us
+ * to suspend the block and return the initial pending message on first render.
+ *
+ * One difference is that _unloadData will not unregister the airtableInterface handler. We don't
+ * support unregistering it at this time for simplicity.
+ *
+ * This class is internal: users should use registerRecordActionDataCallback or useRecordActionData.
+ *
+ * @internal
+ * */
+class PerformRecordAction extends _abstract_model_with_async_data.default {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * The data from the latest record action, or null if none have occurred yet.
+   *
+   * @internal */
+
+  /** @hidden */
+  constructor(sdk, airtableInterface) {
+    super(sdk, 'performRecordAction');
+    this._airtableInterface = airtableInterface;
+    this._hasRegisteredHandler = false;
+    this._hasCompletedInitialDataLoad = false;
+    this.recordActionData = null;
+    this._handlePerformRecordAction = this._handlePerformRecordAction.bind(this);
+  }
+
+  /** @internal */
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchablePerformRecordActionKeys, key);
+  }
+
+  /** @hidden */
+  _handlePerformRecordAction(data) {
+    this.recordActionData = data;
+    this._onChange(WatchablePerformRecordActionKeys.recordActionData, data);
+  }
+
+  /**
+   * This accessor method is defined solely to satisfy the contract of the
+   * AbstractModel class.
+   *
+   * @internal */
+  get _dataOrNullIfDeleted() {
+    return (0, _error_utils.invariant)(false, 'The `data` property of PerformRecordAction should not be referenced');
+  }
+
+  /**
+   * This accessor method is defined because the parent implementation uses _dataOrNullIfDeleted
+   *
+   * @inheritdoc */
+  get isDeleted() {
+    return false;
+  }
+
+  /**
+   * AbstractModelWithAsyncData implementation
+   */
+
+  /** @internal */
+  _onChangeIsDataLoaded() {
+    this._onChange(WatchablePerformRecordActionKeys.isDataLoaded);
+
+    // Handle the case where there was a pending action whilst we were registering the handler.
+    // We only want to do this on the very initial load when we're actually registering the
+    // handler: avoid triggering this when the data is "unloaded" and "loaded".
+    if (!this._hasCompletedInitialDataLoad) {
+      this._hasCompletedInitialDataLoad = true;
+      if (this.recordActionData) {
+        this._handlePerformRecordAction(this.recordActionData);
+      }
+    }
+  }
+
+  /** @internal */
+  async _loadDataAsync() {
+    // Note: Liveapp will throw if a handler has already been registered, so we only register
+    // it once.
+    if (!this._hasRegisteredHandler) {
+      this._hasRegisteredHandler = true;
+      this.recordActionData = await this._airtableInterface.fetchAndSubscribeToPerformRecordActionAsync(this._handlePerformRecordAction);
+    }
+    return [];
+  }
+
+  /** @internal */
+  _unloadData() {
+    // Hack: Don't do anything, since "loading" means registering a handler, and we don't need
+    // to unregister it.
+  }
+
+  /** @internal */
+  static _shouldLoadDataForKey(key) {
+    // Watching recordActionData will load data (aka register handler with liveapp) and trigger
+    // callback when done.
+    return key === WatchablePerformRecordActionKeys.recordActionData;
+  }
+}
+
+/**
+ * Registers a callback to handle "open block" / "perform record action" events (from button field).
+ *
+ * Returns a unsubscribe function that should be used to unregister the callback for cleanup on
+ * component unmount, or if you wish to register a different function.
+ *
+ * Also see {@link useRecordActionData}, which subscribes to the same events in a synchronous way.
+ *
+ * Your block will not receive "perform record action" events until a callback is registered -
+ * they're held until registration to ensure the block is ready to handle the event (e.g. has
+ * finished loading).
+ *
+ * Because of this, we recommend only registering a callback once, in your top level component -
+ * otherwise, messages could be received while not all callbacks have been successfully registered.
+ * Similarly, using both `registerRecordActionDataCallback` and `useRecordActionData` is not
+ * supported.
+ *
+ * You can test your block in development by sending "perform record action" events to your block
+ * in the "Advanced" panel of the block developer tools.
+ *
+ * After releasing your block, you can use it with a button field by choosing the "Open custom
+ * block" action and selecting your block.
+ *
+ * @example
+ * ```js
+ * import React, {useEffect, useState} from 'react';
+ * import {registerRecordActionDataCallback} from '@airtable/blocks/base/ui';
+ *
+ * function LatestRecordAction() {
+ *     const [recordActionData, setRecordActionData] = useState(null);
+ *
+ *     const callback = (data) => {
+ *         console.log('Record action received', data);
+ *         setRecordActionData(data);
+ *     }
+ *
+ *     useEffect(() => {
+ *         // Return the unsubscribe function so it's run on cleanup.
+ *         return registerRecordActionDataCallback(callback);
+ *     }, [callback]);
+ *
+ *     if (recordActionData === null) {
+ *         return <span>No events yet</span>;
+ *     }
+ *
+ *     return (
+ *         <ul>
+ *             <li>Record id: {recordActionData.recordId}</li>
+ *             <li>View id: {recordActionData.viewId}</li>
+ *             <li>Table id: {recordActionData.tableId}</li>
+ *         </ul>
+ *     );
+ * }
+ * ```
+ *
+ */
+exports.PerformRecordAction = PerformRecordAction;
+function registerRecordActionDataCallback(callback) {
+  const {
+    performRecordAction
+  } = sdk;
+  const wrappedCallback = (model, key, data) => {
+    callback(data);
+  };
+  performRecordAction.watch(WatchablePerformRecordActionKeys.recordActionData, wrappedCallback);
+  return () => performRecordAction.unwatch(WatchablePerformRecordActionKeys.recordActionData, wrappedCallback);
+}
+let sdk;
+
+// The application-level Sdk instance must be injected dynamically to avoid
+// circular dependencies at the time of module resolution.
+function __injectSdkIntoPerformRecordAction(_sdk) {
+  sdk = _sdk;
+}

package/dist/esm/base/sdk.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sdk_core = require("../shared/sdk_core");
+var _viewport = _interopRequireDefault(require("./viewport"));
+var _base = _interopRequireDefault(require("./models/base"));
+var _session = _interopRequireDefault(require("./models/session"));
+var _mutations = _interopRequireDefault(require("./models/mutations"));
+var _cursor = _interopRequireDefault(require("./models/cursor"));
+var _settings_button = _interopRequireDefault(require("./settings_button"));
+var _undo_redo = _interopRequireDefault(require("./undo_redo"));
+var _perform_record_action = require("./perform_record_action");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @hidden */ /** */
+// NOTE: The version of React running in the Block SDK is controlled by the block.
+// The SDK should not make too many assumptions about which version of React or
+// ReactDOM is running.
+
+/** @hidden */
+
+/** @internal */
+function defaultUpdateBatcher(applyUpdates) {
+  applyUpdates();
+}
+
+/**
+ * We document this manually.
+ *
+ * @hidden
+ */
+class BaseBlockSdk extends _sdk_core.BlockSdkCore {
+  /** Controls the block's viewport. You can fullscreen the block and add size
+   * constrains using `viewport`.
+   */
+
+  /** Returns information about the active table, active view, and selected records. */
+
+  /**
+   * Controls the block's {@link settingsButton settings button}.
+   */
+
+  /** @hidden */
+
+  /** @internal */
+
+  // When models are updated on the frontend, we want to batch them together and have React do a
+  // single render.
+  //
+  // Without this, in sync-mode React (the current default), anything that triggers an update
+  // (like .setState or .forceUpdate) will instantly, synchronously re-render. So if you have an
+  // update that triggers multiple updates across your tree, you get multiple renders in an
+  // unpredictable order. This is bad because it's unnecessary work and the update order can
+  // contradict react's normal top-down data flow which can cause subtle bugs.
+  //
+  // We set _runWithUpdateBatching to ReactDOM.unstable_batchedUpdates to facilitate this. We
+  // don't know for sure though that React is in use on the page, so we leave actually setting
+  // this when the developer sets up their block with React, in UI.initializeBlock.
+  //
+  // This can be eliminated if we stop supporting versions of React below 18. In React 18,
+  // updates are always batched by default.
+  /** @internal */
+  _runWithUpdateBatching = defaultUpdateBatcher;
+
+  /** @hidden */
+  constructor(airtableInterface) {
+    super(airtableInterface);
+    const sdkInitData = airtableInterface.sdkInitData;
+
+    // Bind the public methods on this class so users can import
+    // just the method, e.g.
+    // import {reload} from '@airtable/blocks/base';
+    this.unstable_fetchAsync = this.unstable_fetchAsync.bind(this);
+    this.viewport = new _viewport.default(sdkInitData.isFullscreen, airtableInterface);
+    this.cursor = new _cursor.default(this);
+    this.settingsButton = new _settings_button.default(airtableInterface);
+    this.undoRedo = new _undo_redo.default(airtableInterface);
+    this.performRecordAction = new _perform_record_action.PerformRecordAction(this, airtableInterface);
+
+    // Now that we've constructed our models, let's hook them up to realtime changes.
+    this._registerHandlers();
+
+    // TODO: freeze this object before we ship the code editor.
+  }
+  /** @internal */
+  _constructSession() {
+    return new _session.default(this);
+  }
+  /** @internal */
+  _constructBase() {
+    return new _base.default(this);
+  }
+  /** @internal */
+  _constructMutations() {
+    return new _mutations.default(this, this.session, this.base, changes => this.__applyModelChanges(changes), updates => this.__applyGlobalConfigUpdates(updates));
+  }
+  /** @internal */
+  __applyModelChanges(changes) {
+    this._runWithUpdateBatching(() => {
+      const changedBasePaths = this.base.__applyChangesWithoutTriggeringEvents(changes);
+      const changedCursorKeys = this.cursor.__applyChangesWithoutTriggeringEvents(changes);
+      const changedSessionKeys = this.session.__applyChangesWithoutTriggeringEvents(changes);
+      this.base.__triggerOnChangeForChangedPaths(changedBasePaths);
+      this.cursor.__triggerOnChangeForChangedKeys(changedCursorKeys);
+      this.session.__triggerOnChangeForChangedKeys(changedSessionKeys);
+    });
+  }
+  /** @internal */
+  __applyGlobalConfigUpdates(updates) {
+    this._runWithUpdateBatching(() => {
+      this.globalConfig.__setMultipleKvPaths(updates);
+    });
+  }
+  /** @internal */
+  _registerHandlers() {
+    // base
+
+    this.__airtableInterface.subscribeToModelUpdates(_ref => {
+      let {
+        changes
+      } = _ref;
+      this.__applyModelChanges(changes);
+    });
+
+    // global config
+    this.__airtableInterface.subscribeToGlobalConfigUpdates(_ref2 => {
+      let {
+        updates
+      } = _ref2;
+      this.__applyGlobalConfigUpdates(updates);
+    });
+
+    // settings button
+    this.__airtableInterface.subscribeToSettingsButtonClick(() => {
+      if (this.settingsButton.isVisible) {
+        this._runWithUpdateBatching(() => {
+          // Since there's an async gap when communicating with liveapp,
+          // no-op if the button has been hidden since it was clicked.
+          this.settingsButton.__onClick();
+        });
+      }
+    });
+
+    // viewport
+    this.__airtableInterface.subscribeToEnterFullScreen(() => {
+      this._runWithUpdateBatching(() => {
+        this.viewport.__onEnterFullscreen();
+      });
+    });
+    this.__airtableInterface.subscribeToExitFullScreen(() => {
+      this._runWithUpdateBatching(() => {
+        this.viewport.__onExitFullscreen();
+      });
+    });
+    this.__airtableInterface.subscribeToFocus(() => {
+      this._runWithUpdateBatching(() => {
+        this.viewport.__focus();
+      });
+    });
+  }
+  /** @internal */
+  __setBatchedUpdatesFn(newUpdateBatcher) {
+    this._runWithUpdateBatching = newUpdateBatcher;
+  }
+
+  /** @hidden */
+  async unstable_fetchAsync(requestJson) {
+    return await this.__airtableInterface.performBackendFetchAsync(requestJson);
+  }
+
+  /** @hidden */
+  getBlockRunContext() {
+    return this.__airtableInterface.sdkInitData.runContext;
+  }
+}
+exports.default = BaseBlockSdk;

package/dist/esm/base/settings_button.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _watchable = _interopRequireDefault(require("../shared/watchable"));
+var _private_utils = require("../shared/private_utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module @airtable/blocks: settingsButton */ /** */
+
+const WatchableSettingsButtonKeys = Object.freeze({
+  isVisible: 'isVisible',
+  click: 'click'
+});
+
+/**
+ * A watchable key in {@link SettingsButton}.
+ * - `isVisible`
+ * - `click`
+ */
+
+/**
+ * Interface to the settings button that lives outside the extension's viewport.
+ *
+ * The {@link useSettingsButton} hook is the recommended way to use the settings button, but you can
+ * also use it with {@link useWatchable} if you want more granular control (for example, to only
+ * show the button conditionally).
+ *
+ * @alias settingsButton
+ * @example
+ * ```js
+ * import {settingsButton} from '@airtable/blocks/base';
+ * import {useWatchable} from '@airtable/blocks/base/ui';
+ *
+ * function AppWithSettings({shouldShowSettingsButton}) {
+ *     useEffect(() => {
+ *         // A count of calls to `show()` and `hide()` is maintained internally. The button will
+ *         // stay visible if there are more calls to `show()` than `hide()` - so here, we check
+ *         // `isVisible` so we only we only call them when necessary.
+ *         // The button is not visible by default.
+ *         if (shouldShowSettingsButton && !settingsButton.isVisible) {
+ *             settingsButton.show();
+ *         } else if (!shouldShowSettingsButton && settingsButton.isVisible) {
+ *             settingsButton.hide();
+ *         }
+ *     });
+ *
+ *     useWatchable(settingsButton, 'click', function() {
+ *         alert('Clicked!');
+ *     });
+ * }
+ * ```
+ * @docsPath models/SettingsButton
+ */
+class SettingsButton extends _watchable.default {
+  /** @internal */
+  static _className = 'SettingsButton';
+  /** @internal */
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableSettingsButtonKeys, key);
+  }
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+  constructor(airtableInterface) {
+    super();
+    this._refCount = 0;
+    this._airtableInterface = airtableInterface;
+  }
+
+  /**
+   * Whether the settings button is being shown.
+   * Can be watched.
+   */
+  get isVisible() {
+    return this._refCount > 0;
+  }
+
+  /**
+   * Show the settings button.
+   */
+  show() {
+    // Is now visible: trigger change watches and set it to be visible
+    if (this._refCount === 0) {
+      this._onChange(WatchableSettingsButtonKeys.isVisible, true);
+      this._airtableInterface.setSettingsButtonVisibility(true);
+    }
+    this._refCount += 1;
+  }
+
+  /**
+   * Hide the settings button.
+   *
+   * Note: A count of calls to `show()` and `hide()` is maintained internally. The button will
+   * stay visible if there are more calls to `show()` than `hide()`.
+   */
+  hide() {
+    // Be forgiving if hide() is called too many times, since we don't expose the count
+    if (this._refCount > 0) {
+      this._refCount -= 1;
+    }
+
+    // Should no longer be visible: trigger change watches and set it to be not visible
+    if (this._refCount === 0) {
+      this._onChange(WatchableSettingsButtonKeys.isVisible, false);
+      this._airtableInterface.setSettingsButtonVisibility(false);
+    }
+  }
+
+  /** @internal */
+  __onClick() {
+    this._onChange(WatchableSettingsButtonKeys.click);
+  }
+}
+var _default = exports.default = SettingsButton;

package/dist/{cjs → esm}/base/types/airtable_interface.js

@@ -7,7 +7,7 @@ exports.BlockRunContextType = void 0;
 // BlockRunContextType, BlockInstallationPageBlockRunContext, ViewBlockRunContext, BlockRunContext
 // must be kept in sync with block_run_context.tsx in hyperbase repo
 /** @hidden */
-var BlockRunContextType = exports.BlockRunContextType = /*#__PURE__*/function (BlockRunContextType) {
+let BlockRunContextType = exports.BlockRunContextType = /*#__PURE__*/function (BlockRunContextType) {
   BlockRunContextType["DASHBOARD_APP"] = "dashboardApp";
   BlockRunContextType["VIEW"] = "view";
   return BlockRunContextType;