@microsoft/sp-adaptive-card-extension-base 1.23.2 → 1.24.0-beta.2

package/lib-esm/BaseAdaptiveCardExtension.js

@@ -0,0 +1,1237 @@
+import { BaseComponent, _PropertyMetadataProcessor } from '@microsoft/sp-component-base';
+import { DisplayMode, Version, _ES5CompatibleClass } from '@microsoft/sp-core-library';
+import { cloneDeep, isEqual, update } from '@microsoft/sp-lodash-subset';
+import { _EngagementLogger, _QosMonitor } from '@microsoft/sp-diagnostics';
+import { _WebPartLoadDataCollector } from '@microsoft/sp-component-base';
+import { getCardRenderParameters } from './ac-template/util/getCardRenderParameters';
+import { CacheManager } from './caching/CacheManager';
+import { isAdaptiveCardExtensionMySiteCacheEnabled, isEnableDashboardUniqueIdInEngagementLogsEnabled } from './common/Flights';
+import { BaseView } from './views/base/BaseView';
+import { BaseCardView } from './views/card/BaseCardView';
+import { DefaultCardView } from './views/card/DefaultCardView';
+import { QuickViewNavigator } from './views/navigator/QuickViewNavigator';
+import { ViewNavigator } from './views/navigator/ViewNavigator';
+import { _PerformanceLogger } from '@msinternal/sp-telemetry';
+import { isAddAppHostTypeToCardActionKSActivated, isLogEngagementExtraDataKSActivated, isIsolatedAdaptiveCardExtensionWebPropertyPaneWorkAroundKSActivated, isReduceRenderTimeoutKSActivated, isSurfaceOnBeforeActionKSActivated, isSupportActionExecuteKSActivated, isAddVetoForACEKSActivated, isLogBotIdAndTeamsConnectedAppIdKSActivated, isSerializeConnectedTeamsAppIdKSActivated, isLogExecuteAsSubmitActionKSActivated, isDashboardCardDeeplinkingKSActivated, isUpdateCardViewForQVRenderTypeKSActivated } from './common/Killswitches';
+import { LocalStorageACECache } from './caching/cache/LocalStorageACECache';
+import { BaseQuickView } from './views/quickView/BaseQuickView';
+import { ASHA_ACE_LOAD_FAILURE } from './AdaptiveCardExtensionLoader';
+import { ADAPTIVECARDEXTENSION_CARDACTION } from '@msinternal/odsp-analytics/lib/VivaConnectionsAnalytics/VivaConnectionsAnalyticsEngagementEvents';
+const DEFAULT_CARD_SIZE = 'Medium';
+const DEFAULT_VIEW_ID = '_InternalDefaultCardView';
+const DEFAULT_ASYNC_RENDER_COMPLETED_TIMEOUT_TIME = 15000; // 15 seconds
+const UPDATED_ASYNC_RENDER_COMPLETED_TIMEOUT_TIME = 10000; // 10 seconds
+const VIVA_CONNECTIONS_APP_ID = 'd2c6f111-ffad-42a0-b65e-ee00425598aa';
+const VIVA_CONNECTIONS_NAME = 'MEE';
+const ADAPTIVECARDEXTENSION_COMPONENTEVENT = 'AdaptiveCardExtension.ComponentEvent';
+/* eslint-disable @typescript-eslint/member-ordering */ // Disable for this file so we can group public/internal APIs together
+/**
+ * Base class for Adaptive Card Extensions.
+ *
+ * @remarks Adaptive Card Extensions must inherit from this class.
+ *
+ * @public
+ */ export class BaseAdaptiveCardExtension extends BaseComponent {
+    // #region Getters
+    /**
+   * The {@link ViewNavigator} for the Card view.
+   *
+   * @readonly
+   */ get cardNavigator() {
+        if (!this._cardNavigator) {
+            this._cardNavigator = this._initializeCardNavigator();
+        }
+        return this._cardNavigator;
+    }
+    /**
+   * The current {@link CardSize}.
+   *
+   * @readonly
+   */ get cardSize() {
+        return this._cardSize;
+    }
+    /**
+   * The value of this property is stored in the serialized data of the Adaptive Card Extension. It can be used to
+   * manage versioning of the Adaptive Card Extension.
+   *
+   * @remarks The default version is 1.0.
+   *
+   * @readonly
+   */ get dataVersion() {
+        return Version.parse('1.0');
+    }
+    /**
+   * The description of the Adaptive Card Extension defined in the manifest.
+   *
+   * @readonly
+   */ get description() {
+        return this._description;
+    }
+    /**
+   * The current {@link @microsoft/sp-core-library#DisplayMode}.
+   *
+   * @readonly
+   */ get displayMode() {
+        return this._displayMode;
+    }
+    /**
+   * The custom, persisted properties of the Adaptive Card Extension.
+   *
+   * @readonly
+   */ get properties() {
+        return this._properties;
+    }
+    /**
+   * The current site id.
+   *
+   * @internal
+   * @readonly
+   */ get siteId() {
+        return this.context.pageContext.site.id.toString();
+    }
+    /**
+   * The current item id.
+   *
+   * @internal
+   * @readonly
+   */ get itemId() {
+        return this.context.pageContext.listItem?.uniqueId;
+    }
+    /**
+   * Whether the my site cache is enabled
+   *
+   * @internal
+   * @readonly
+   */ get mySiteCacheEnabled() {
+        return isAdaptiveCardExtensionMySiteCacheEnabled();
+    }
+    /**
+   * {@link QuickViewNavigator} is a {@link ViewNavigator} for the Quick view.
+   *
+   * @readonly
+   */ get quickViewNavigator() {
+        if (!this._quickViewNavigator) {
+            this._quickViewNavigator = this._initializeQuickViewNavigator();
+        }
+        return this._quickViewNavigator;
+    }
+    /**
+   * Indicates whether the Adaptive Card Extension was rendered from persisted data or
+   * initialized from a default state.
+   *
+   * @readonly
+   */ get renderedFromPersistedData() {
+        return this._renderedFromPersistedData;
+    }
+    /**
+   * Indicates whether the Adaptive Card Extension has initially rendered.
+   *
+   * @readonly
+   */ get renderedOnce() {
+        return this._renderedOnce;
+    }
+    /**
+   * The current {@link RenderType}.
+   *
+   * @readonly
+   */ get renderType() {
+        return this._renderType;
+    }
+    /**
+   * This property defines metadata for the Adaptive Card Extension property bag. The metadata can help SharePoint understand
+   * the content of the properties better and perform relevant services on the data.
+   *
+   * @remarks See {@link IAdaptiveCardExtensionPropertiesMetadata} for more information about how to define metadata.
+   *
+   * @virtual
+   */ get propertiesMetadata() {
+        return undefined;
+    }
+    /**
+   * Indicates whether the ACE is rendering in async mode.
+   *
+   * @remarks
+   * If the ACE overrides this field to return true, then it needs to call renderCompleted API after the ACE finishes initializing.
+   *
+   * The default value is false.
+   *
+   * @beta
+   */ get isRenderAsync() {
+        return false;
+    }
+    /**
+   * Gets the custom state of the Adaptive Card Extension.
+   *
+   * @remarks This property is automatically shared across registered Views.
+   *
+   * @remarks This property can only be initialized once, and should be done in the constructor or {@link onInit}.
+   *
+   * @remarks If this property is not initialized, {@link BaseAdaptiveCardExtension.setState} cannot be called.
+   *
+   * @remarks This property should not be directly updated. Please use {@link BaseAdaptiveCardExtension.setState} to update the state after initialization.
+   *
+   * @readonly
+   */ get state() {
+        return this._state;
+    }
+    set state(initialState) {
+        if (this._state) {
+            throw new Error('state can only be initialized once');
+        }
+        this._state = initialState;
+    }
+    // #endregion
+    // #region Public Virtual Methods
+    /**
+   * This value is displayed in Card and Quick view unless it is explicitly overridden by the Views.
+   * It is also displayed as the Property Pane title.
+   *
+   * @remarks By default, this will return the title defined in the manifest.
+   *
+   * @virtual
+   */ get title() {
+        return this._title;
+    }
+    /**
+   * Extra properties initialized in the specific card used for when card is loaded telemetry.
+   *
+   * @internal
+   * @virtual
+   */ get _aceLoadExtraData() {
+        return {};
+    }
+    /**
+   * Extra properties initialized in the specific card used for the action engagement telemetry.
+   *
+   * @internal
+   * @virtual
+   */ get _cardActionEngagementExtraData() {
+        return {};
+    }
+    /**
+   * The icon url used to render an icon on the Card view.
+   *
+   * @remarks By default, this will return the iconImageUrl defined in the manifest.
+   *
+   * @virtual
+   */ get iconProperty() {
+        return this._iconProperty;
+    }
+    /**
+   * Get the Property Pane configuration for this Adaptive Card Extension. If an Adaptive Card Extension
+   * wants to use the Property Pane, then this method must be overriden.
+   *
+   * @remarks Property Pane resources can be defer loaded to reduce bundle size. See {@link BaseAdaptiveCardExtension.loadPropertyPaneResources}.
+   *
+   * @virtual
+   */ getPropertyPaneConfiguration() {
+        return {
+            pages: []
+        };
+    }
+    /**
+   * API to enable asynchronous loading of Property Pane related resources of the Adaptive Card Extension.
+   *
+   * @remarks No Property Pane APIs will be called before this method resolves.
+   *
+   * @remarks No Property Pane events will be raised until this method resolves except for `PropertyPaneConfigurationComplete`,
+   * which can be used to clean up any pending resources.
+   *
+   * @virtual
+   */ loadPropertyPaneResources() {
+        return Promise.resolve();
+    }
+    /**
+   * Override the default cache settings.
+   *
+   * @beta
+   * @virtual
+   */ getCacheSettings() {
+        return {};
+    }
+    /**
+   * This virtual method returns a subset of the state object that will be cached by the client.
+   *
+   * @remarks If not overriden, this will return an empty object.
+   * @param state - A shallow clone of the AdaptiveCardExtension state object.
+   *
+   * @beta
+   * @virtual
+   */ getCachedState(state) {
+        return {};
+    }
+    /**
+   * Lifecycle method called when a notification is received for this Adaptive Card Extension.
+   *
+   * @remarks If the notification should be handled by this Adaptive Card Extension then a registered quick view id
+   * should be returned. Otherwise, returning undefined will result in the next, if any, Adaptive Card Extension
+   * to potentially handle the notification event.
+   *
+   * @remarks Only one Adaptive Card Extension can handle a notification event. If the event is handled,
+   * then propagation is finished.
+   *
+   * @param notificationArguments - The {@link INotificationArguments} for the current notification event.
+   *
+   * @returns A registered quick view id to open or undefined.
+   *
+   * @beta
+   * @virtual
+   */ onNotificationReceived(notificationArguments) {
+        return undefined;
+    }
+    /**
+   * Lifecycle method called before Action is passed to {@link IAdaptiveCardExtensionActionView.onAction}.
+   *
+   * @param action - {@link IOnBeforeActionArguments} for the current action.
+   *
+   * @remarks This method is not intended to be used to cancel the action or to change the flow.
+   *
+   * @virtual
+   * @public
+   */ onBeforeAction(action) {
+    /* EMPTY BLOCK */ }
+    /**
+   * Internal onBeforeAction method used to consolidate methods that need to run across platforms.
+   * @param action - {@link IOnBeforeActionArguments} for the current action.
+   *
+   * @internal
+   */ _onBeforeAction(action, location, mobileSessionId, mobileBootType, componentName) {
+        if (isSupportActionExecuteKSActivated() && action.type === 'Execute') {
+            return;
+        }
+        this._logCardActionEngagement(action.type, location, mobileSessionId, mobileBootType, componentName);
+        //
+        // If a develoer calls setState we won't fire update.
+        // Example: before quickView action.
+        //
+        this._beginUpdate();
+        try {
+            this.onBeforeAction(action);
+        } finally{
+            this._endUpdate();
+        }
+    }
+    /**
+   * Pass the action arguments onto the current view to handle.
+   *
+   * @param action - The {@link IBaseActionArguments} for the current event.
+   *
+   * @internal
+   */ _internalOnAction(action) {
+        const currentView = // Once the isKeyboardFocusViewNavChangesKSActivated KS is graduated, all the type checks for `_currentView instanceof BaseView` can be removed.
+        this.navigator._currentView instanceof BaseView ? this.navigator._currentView : this.navigator._currentView.view;
+        if (currentView && currentView.onAction) {
+            if (isSupportActionExecuteKSActivated() && action.type === 'Execute') {
+                // when killswitched is pulled for Action.Execute do not pass action to the view.
+                return;
+            }
+            currentView.onAction(action);
+        } else {
+            // logging error. We're expecting IAdaptiveCardExtensionActionView
+            const error = new Error('_internalOnAction is called for non-actionable ACE view');
+            this._logInternalOnActionError(error, 'internalOnActionFailure');
+            throw error;
+        }
+    }
+    /**
+   * Pass the action error arguments onto the current view to handle.
+   *
+   * @param actionError - The {@link IBaseActionErrorArguments} for the current event.
+   *
+   * @internal
+   */ _internalOnActionError(actionError) {
+        const currentView = this.navigator._currentView instanceof BaseView ? this.navigator._currentView : this.navigator._currentView.view;
+        if (currentView && currentView.onActionError) {
+            currentView.onActionError(actionError);
+        } else {
+            // logging error. We're expecting IAdaptiveCardExtensionActionView
+            const error = new Error('_internalOnActionError is called for non-actionable ACE view');
+            this._logInternalOnActionError(error, 'internalOnActionErrorFailure');
+            throw error;
+        }
+    }
+    /**
+   * Lifecycle method called before serialization.
+   *
+   * @virtual
+   */ onBeforeSerialize() {
+    /* EMPTY BLOCK */ }
+    /**
+   * Lifecycle method called after the Adaptive Card Extension's properties have been
+   * updated by a source other than the property pane (except for isolated Adaptive Card Extensions).
+   *
+   * @remarks For isolated Adaptive Card Extensions, this lifecycle is invoked instead
+   * of `onPropertyPaneFieldChanged`.
+   *
+   * @param prevProperties - The Adaptive Card Extension properties before the update.
+   *
+   * @virtual
+   */ onAfterPropertiesUpdatedExternally(prevProperties) {
+    /* EMPTY BLOCK */ }
+    /**
+   * Lifecycle method called before the property bag is populated with the deserialized property object.
+   *
+   * @remarks
+   * The default implementation is a no-op. An Adaptive Card Extension developer can override this API if the deserialized object
+   * does not fully reflect the initial state of the property bag. This gives the Adaptive Card Extension developer a chance to
+   * populate the property bag right after the data is deserialized to an object.
+   *
+   * An important scenario to use deserialize is upgrading. An upgraded Adaptive Card Extension may load the data
+   * that was serialized by an older version of the Adaptive Card Extension that supported a different schema of the property bag,
+   * resulting the deserialized object to be incosistent with the current schema of the property bag. The developer
+   * can use `onAfterDeserialize` to check the dataVersion and fix the property bag.
+   *
+   * @param deserializedProperties - The object deserialized from the stored data. Note that the schema of this object
+   * is not necessarily consistent with the current property bag, because the serialization could have been done by
+   * an older version of the Adaptive Card Extension
+   * @param dataVersion - The data version of the stored data being deserialized. You can use this value to determine
+   * if the data was serialized by an older Adaptive Card Extension. Adaptive Card Extensions can define their data version
+   * by overriding the dataVersion property.
+   *
+   * @returns The property bag of the Adaptive Card Extension
+   *
+   * @virtual
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onAfterDeserialize(deserializedProperties, dataVersion) {
+        return deserializedProperties;
+    }
+    /**
+   * Lifecycle method called after the {@link @microsoft/sp-core-library#DisplayMode} changed.
+   *
+   * @virtual
+   *
+   * @param oldDisplayMode - The old display mode.
+   */ onDisplayModeChanged(oldDisplayMode) {
+    /* EMPTY BLOCK */ }
+    /**
+   * Lifecycle method called before disposing the Adaptive Card Extension.
+   *
+   * @virtual
+   */ onDispose() {
+    // noop
+    }
+    /**
+   * Lifecycle method called during initialization.
+   *
+   * @remarks Asynchronous data fetches should be started during this lifecycle. Rendering can either be dependent on the result
+   * or, if resolved immediately, a fetching data state can be rendered.
+   *
+   * @param cachedLoadParameters - Parameters containing the cached state object (see {@link BaseAdaptiveCardExtension.getCachedState}), which can be used to rehydrate the AdaptiveCardExtension.
+   * If undefined, the AdaptiveCardExtension was not cached or the cache expired.
+   *
+   * @alpha
+   * @virtual
+   */ onInit(cachedLoadParameters) {
+        return Promise.resolve();
+    }
+    /**
+   * @internal
+   */ _initializeCardNavigator() {
+        return new ViewNavigator(this._navigatorCallback, this._onViewInitialized);
+    }
+    /**
+   *  @internal
+   */ _initializeQuickViewNavigator() {
+        return new QuickViewNavigator(this._navigatorCallback, this._onQuickViewInitialized, this._closeQuickViewCallback);
+    }
+    /**
+   * Lifecycle method called when a Property Pane field is changed.
+   *
+   * @remarks This is invoked for reactive Property Panes.
+   *
+   * @param propertyPath - JSON path of the property in the property bag.
+   *  In the case of custom field, if no target property is provided then a custom value is assigned,
+   *  which will be in the form of `__CustomField_<key provided when the custom field is created>`.
+   * @param oldValue - Old value of the property.
+   *  This value could be undefined/empty in the case of custom field.
+   * @param newValue - New value of the property.
+   *  This value could be undefined/empty in the case of custom field.
+   *
+   * @virtual
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onPropertyPaneFieldChanged(propertyPath, oldValue, newValue) {
+    /* noop */ }
+    /**
+   * Lifecycle method called when the {@link RenderType} changes.
+   *
+   * @param oldRenderType - The previous {@link RenderType}.
+   *
+   * @virtual
+   */ onRenderTypeChanged(oldRenderType) {
+    /* EMPTY BLOCK */ }
+    /**
+   * The id of the initial Card view.
+   *
+   * @remarks A Card view with this id must be registered with {@link cardNavigator} before rendering.
+   *
+   * @remarks By default, this returns undefined and will render a default Card view.
+   *
+   * @virtual
+   */ renderCard() {
+        return undefined;
+    }
+    /**
+   * Provide Property Pane groups that will appear above the framework-level properties such as card size.
+   *
+   * @virtual
+   * @internal
+   */ _getPreFrameworkPropertyPaneConfiguration() {
+        return [];
+    }
+    /**
+   * Whether the framework will add property pane groups (e.g., cardSize)
+   *
+   * @virtual
+   * @internal
+   */ get _isFrameworkPropertyPaneEnabled() {
+        return true;
+    }
+    // #endregion
+    // #region Public APIs
+    /**
+   * Sets the visibility of the Adaptive Card Extension and re-render
+   *
+   * @remarks This method should be called after a card view has been registered.
+   *          Otherwise visibility change will not be applied to the Adaptive Card.
+   *
+   * @readonly
+   */ get isVisible() {
+        return this._isVisible;
+    }
+    set isVisible(value) {
+        this._isVisible = value;
+        if (this._isInitialized && (this.cardNavigator._getRegistrySize() > 0 || this.cardNavigator._currentView instanceof BaseCardView ? this.cardNavigator._currentView : this.cardNavigator._currentView.view)) {
+            this.context._host.onVisibilityChanged(this._getRenderArguments(this.renderType));
+        }
+    }
+    /**
+   * Lifecycle method that signifies ACE has finished loading.
+   * When this API is called, performance data will be generated.
+   * Depending on `didUpdate` parameter, end marker for the rendering lifecycle can change.
+   *   If an ACE received LKG data and does NOT need to update, render is completed when LKG is used.
+   *   If an ACE received LKG data and DOES need to update, render is completed when new render arguments are used.
+   *   If an ACE does not receive LKG data, render is completed when new render arguments are used.
+   *
+   * @param didUpdate - boolean value indicating if ACE has updated.
+   *
+   * @beta
+   */ renderCompleted(didUpdate) {
+        if (this._renderCompletedPromiseResolver) {
+            this._renderCompletedPromiseResolver(didUpdate);
+        }
+    }
+    _endMarkForRenderComplete(didUpdate, didTimeOut) {
+        const monitor = new _QosMonitor(`AdaptiveCardExtension.RenderCompleted`);
+        if (!this._isLoggedRenderPerf) {
+            if (didUpdate) {
+                if (didTimeOut) {
+                    _PerformanceLogger.endFailureForComponent(this._perfTagName, 'TimeOut', undefined /** Error */ , undefined /** Result Type */ , !isAddVetoForACEKSActivated() ? ASHA_ACE_LOAD_FAILURE : undefined);
+                } else {
+                    _PerformanceLogger.endMarkForComponent(this._perfTagName);
+                }
+            } else {
+                // this._lkgRenderTime will be defined if this.isRenderAsync is equal to true
+                _PerformanceLogger.endMarkForComponentWithTimestamp(this._perfTagName, this._lkgRenderTime);
+            }
+            this._isLoggedRenderPerf = true;
+        }
+        const aceLoadData = _WebPartLoadDataCollector.collect(this.context.manifest, this._perfTagName, this.context.pageContext);
+        const extraData = {
+            ...aceLoadData,
+            isInternal: this.manifest.isInternal || false,
+            isInitializedWithLKG: this._isInitializedWithLKG,
+            didTimeOut: didTimeOut,
+            didUpdate: didUpdate,
+            displayMode: this.displayMode
+        };
+        if (didTimeOut) {
+            monitor.writeUnexpectedFailure('', undefined, extraData);
+        } else {
+            monitor.writeSuccess(extraData);
+        }
+        this.context._host.onRenderCompleted(this.instanceId, didUpdate);
+        this._clearRenderCompletedGuardTimer();
+    }
+    _resolveRenderCompleted() {
+        this._renderCompletedPromise.then((didUpdate)=>{
+            this._endMarkForRenderComplete(didUpdate, false);
+        }).catch(()=>{
+            this._endMarkForRenderComplete(true, true);
+        });
+    }
+    /**
+   * Update the state of the Adaptive Card Extension and re-render.
+   *
+   * @remarks Calling {@link BaseAdaptiveCardExtension.setState} without a new state will trigger the code path to re-render with current state.
+   * However, this does not guarantee a re-render. Re-render will only occur if either state or content of view template has changed.
+   *
+   * @remarks {@link BaseAdaptiveCardExtension.state} must have been initialized before calling {@link BaseAdaptiveCardExtension.setState}.
+   *
+   * @param newState - The new state to set.
+   */ setState(newState) {
+        this._internalSetState(newState, true);
+    }
+    /**
+   * @param newState - The new state to set.
+   * @param isUpdate - Boolean to trigger a re-render of the ACE. By default ACE will update and re-render.
+   *
+   * @internal
+   */ _internalSetState(newState, isUpdate = true) {
+        if (!this._state) {
+            throw new Error('state must be initialized before calling setState');
+        }
+        if (newState) {
+            this._state = {
+                ...this.state,
+                ...cloneDeep(newState)
+            };
+            this.cardNavigator._forEach(this._onViewInitialized);
+            this.quickViewNavigator._forEach(this._onQuickViewInitialized);
+        }
+        if (this._isInitialized && !this._isUpdating && isUpdate) {
+            this.context._host.update(this._getRenderArguments(this._renderType));
+        }
+    }
+    /**
+   * Template updating with data updates is equivalent to creating a new card.
+   * Unlike data updates, we require the disposal of the old card template factory to create a new renderer
+   *
+   * @deprecated Use `setState` instead
+   * @internal
+   *
+   * @param renderTypeToUpdate - RenderType
+   */ update(renderTypeToUpdate, updateOnlyData = false) {
+        const card = this._getRenderArguments(renderTypeToUpdate, updateOnlyData);
+        this.context._host.update(card);
+    }
+    // #endregion
+    // #region Internal APIs
+    /**
+   * If this._cardObject is undefined create a new object and assign it.
+   * Otherwise update the existing this._cardObject according to RenderType
+   * @param renderTypeToUpdate - RenderType
+   *
+   * @internal
+   */ _getRenderArguments(renderTypeToUpdate, updateOnlyData = false, initialViewId) {
+        const monitor = new _QosMonitor(`AdaptiveCardExtension.GetRenderArguments.${renderTypeToUpdate}`);
+        try {
+            if (!this._isInitialized) {
+                monitor.writeUnexpectedFailure('ACE is not initialized');
+                throw new Error(`${this.context.manifest.alias} is not initialized`);
+            }
+            this._setRenderType(renderTypeToUpdate, initialViewId);
+            if (renderTypeToUpdate === 'Card' && this.cardNavigator.size === 0) {
+                let initialCardId = this.renderCard();
+                if (!initialCardId) {
+                    initialCardId = DEFAULT_VIEW_ID;
+                    this.cardNavigator.register(initialCardId, ()=>new DefaultCardView(this.description));
+                }
+                this.cardNavigator.push(initialCardId, true);
+            }
+            if (this._ACRenderArgs === undefined) {
+                this._ACRenderArgs = {
+                    card: renderTypeToUpdate === 'Card' ? this._getCard(updateOnlyData) : undefined,
+                    isVisible: this._isVisible,
+                    instanceId: this.instanceId,
+                    lastUpdatedType: renderTypeToUpdate,
+                    quickLook: renderTypeToUpdate === 'QuickView' ? this._getQuickView(updateOnlyData) : undefined
+                };
+            } else {
+                this._updateRenderArgs(renderTypeToUpdate, updateOnlyData);
+            }
+            if (/**
+         * When graduating isIsolatedAdaptiveCardExtensionWebPropertyPaneWorkAroundKSActivated only leave this.displayMode check.
+         * This is a workaround when load ACE WP in isolation to render the property pane. We need to update LKG to keep data consistent after editing.
+         * owner: joyi
+         */ (!isIsolatedAdaptiveCardExtensionWebPropertyPaneWorkAroundKSActivated() && !!this.context.manifest.isolatedDomain || this.displayMode === DisplayMode.Read) && renderTypeToUpdate === 'Card') {
+                const cacheObject = this._cacheManager?.save(this._cacheKey, this.instanceId, this.cardNavigator._currentView instanceof BaseCardView ? this.cardNavigator._currentView : this.cardNavigator._currentView.view, this._ACRenderArgs, this.cardNavigator.viewStack.map((cvItem)=>typeof cvItem === 'string' ? cvItem : cvItem.id), this.getCachedState({
+                    ...this._state
+                }), this.manifest, this.cardNavigator.currentId);
+                this._ACRenderArgs.cacheObject = cacheObject;
+            }
+            let extraData;
+            if (!this._isLoggedRenderPerf && !this.isRenderAsync) {
+                _PerformanceLogger.endMarkForComponent(this._perfTagName);
+                extraData = _WebPartLoadDataCollector.collect(this.context.manifest, this._perfTagName, this.context.pageContext);
+                this._isLoggedRenderPerf = true;
+                this.context._host.onRenderCompleted(this.instanceId, true);
+            }
+            extraData = {
+                ...extraData,
+                isInternal: this.manifest.isInternal || false,
+                displayMode: this.displayMode
+            };
+            monitor.writeSuccess(extraData);
+        } catch (err) {
+            let extraData;
+            if (!this._isLoggedRenderPerf) {
+                _PerformanceLogger.endFailureForComponent(this._perfTagName, 'Render', err, undefined /** Result Type */ , !isAddVetoForACEKSActivated() ? ASHA_ACE_LOAD_FAILURE : undefined);
+                extraData = _WebPartLoadDataCollector.collect(this.context.manifest, this._perfTagName, this.context.pageContext);
+                this._isLoggedRenderPerf = true;
+                this.context._host.onRenderCompleted(this.instanceId, true);
+            }
+            monitor.writeUnexpectedFailure('failedGetRenderArguments', err, {
+                ...extraData,
+                alias: this.context.manifest.alias,
+                deviceContext: this.context.deviceContext,
+                instanceId: this.instanceId,
+                isInternal: this.manifest.isInternal || false,
+                manifestId: this.context.manifest.id,
+                displayMode: this.displayMode
+            });
+            if (this.manifest.isInternal && this.displayMode === DisplayMode.Edit) {
+                // log to ASHA edit customer promise for 1P card view in edit mode.
+                // note: all actions are blocked in edit mode, thus only card view is available.
+                this.context._logEditCustomerPromiseFailure(this.manifest.alias, err.message, 'AdaptiveCardExtensionGetRenderArgumentsFailed');
+            }
+            // we want to re-throw the error here to stop execution and provide error details to the dev
+            throw err;
+        }
+        return this._ACRenderArgs;
+    }
+    /**
+   * @internal
+   */ _propertiesMetadata() {
+        return this.propertiesMetadata;
+    }
+    /**
+   * @internal
+   */ _getPropertyPaneConfiguration() {
+        return this.getPropertyPaneConfiguration();
+    }
+    /**
+   * The current {@link ViewNavigator}.
+   *
+   * @remarks If the current {@link BaseAdaptiveCardExtension.renderType} is `Card`
+   * then returns {@link BaseAdaptiveCardExtension.cardNavigator}.
+   *
+   * @remarks If the current {@link BaseAdaptiveCardExtension.renderType} is `QuickView`
+   * then returns {@link BaseAdaptiveCardExtension.quickViewNavigator}.
+   */ get navigator() {
+        return this.renderType === 'Card' ? this.cardNavigator : this.quickViewNavigator;
+    }
+    /**
+   * @internal
+   */ _internalDeserialize(data) {
+        if (data.title) {
+            this._title = data.title;
+        }
+        if (data.iconProperty) {
+            this._iconProperty = data.iconProperty;
+        }
+        if (data.description) {
+            this._description = data.description;
+        }
+        if (data.cardSize) {
+            this._cardSize = data.cardSize;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const deserializedProperties = data.properties;
+        if (this.renderedFromPersistedData) {
+            _PropertyMetadataProcessor.reInstateServerProcessedData(this.propertiesMetadata, deserializedProperties, data.serverProcessedContent);
+            // Unset the server processed content to avoid duplicated process in BaseWebPart.
+            data.serverProcessedContent = undefined;
+        }
+        if (this._properties) {
+            // For isolated ACEs we need to keep the same reference for the lifecycle of the ACE
+            Object.assign(this._properties, deserializedProperties);
+        } else {
+            // When this is called when the ACE is first created using a preconfigured entry, data.dataVersion could be undefined
+            this._properties = this.onAfterDeserialize(deserializedProperties, data.dataVersion ? Version.parse(data.dataVersion) : this.dataVersion);
+        }
+        if (this.isRenderAsync) {
+            this._startRenderCompletedGuardTimer();
+        }
+        this._cacheKey = this._generateCacheKey(data.dashboardWebPartInstanceId);
+        this._instanceIdForLogs = data.instanceIdForLogs ? data.instanceIdForLogs : data.instanceId;
+        this._dashboardUniqueId = data.dashboardUniqueId;
+    }
+    /**
+   * @internal
+   */ _internalInitialize(context, addedFromPersistedData, initialDisplayMode, tagName, isInitializedWithLKG, appHostType) {
+        super._initializeContext(context);
+        this._displayMode = initialDisplayMode;
+        this._renderedOnce = false;
+        this._renderedFromPersistedData = addedFromPersistedData;
+        this._cacheManager = new CacheManager(this.context, ()=>this.cardSize, ()=>this.iconProperty, ()=>this.title, this._onViewInitialized, this.getCacheSettings());
+        this._perfTagName = tagName;
+        this._isInitializedWithLKG = isInitializedWithLKG;
+        if (!isAddAppHostTypeToCardActionKSActivated()) {
+            this._appHostType = appHostType;
+        }
+    }
+    /**
+   * Internal API to switch the Adaptive Card Extension's display mode.
+   *
+   * The AdaptiveCardExtensionWebPart, in its method of the same name, calls this method.
+   *
+   * @param newDisplayMode - the new DisplayMode of the Web Part hosting this Adaptive Card Extension.
+   *
+   * @internal
+   */ _internalSetDisplayMode(newDisplayMode) {
+        if (this._displayMode !== newDisplayMode) {
+            const oldDisplayMode = this._displayMode;
+            this._displayMode = newDisplayMode;
+            this.onDisplayModeChanged(oldDisplayMode);
+        }
+    }
+    /**
+   * API to enable asynchronous loading of property pane related resources of a web part.
+   *
+   * @internal
+   */ _loadPropertyPaneResources() {
+        return this.loadPropertyPaneResources();
+    }
+    /**
+   * Invoked from the AdaptiveCardExtensionWebPart's `onPropertyPaneFieldChanged` implementation.
+   *
+   * @param propertyPath - property to update.
+   * @param oldValue - old value.
+   * @param newValue - new value.
+   *
+   * @internal
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _onPropertyPaneFieldChanged(propertyPath, oldValue, newValue) {
+        if (!isEqual(oldValue, newValue)) {
+            this._updateProperty(propertyPath, newValue);
+            this.onPropertyPaneFieldChanged(propertyPath, oldValue, newValue);
+        }
+    }
+    /**
+   * @internal
+   */ _renderCompleted() {
+        this._renderedOnce = true;
+    }
+    /**
+   * @internal
+   */ _internalOnAfterInit() {
+        this._isInitialized = true;
+        if (this.isRenderAsync) {
+            // If LKG cache exists the host would have rendered it while the ACE was initializing.
+            // Capture this._lkgRenderTime after async rendering ACE is initialized.
+            this._lkgRenderTime = _PerformanceLogger.now();
+        }
+    }
+    /**
+   * Return the persisted content of Adaptive Card Extension.
+   *
+   * @internal
+   */ _internalSerialize() {
+        this.onBeforeSerialize();
+        const aceData = {
+            dataVersion: this.dataVersion.toString(),
+            id: this.componentId,
+            instanceId: this.instanceId,
+            properties: this.properties,
+            title: this.title,
+            description: this._description,
+            iconProperty: this.iconProperty,
+            cardSize: this._cardSize
+        };
+        if (!isSerializeConnectedTeamsAppIdKSActivated()) {
+            aceData.connectedTeamsAppId = this.manifest.connectedTeamsAppId;
+        }
+        return aceData;
+    }
+    /**
+   * Internal API called by the AdaptiveCardExtensionWebPart / Bridge to inform the AdaptiveCardExtension that the RenderType has changed
+   * This API calls the onRenderTypeChanged event method
+   *
+   * @internal
+   */ _setRenderType(newRenderType, initialViewId) {
+        if (this._renderType !== newRenderType) {
+            const oldRenderType = this._renderType;
+            // When the Quick view closes, clear the view stack
+            if (oldRenderType === 'QuickView') {
+                this.quickViewNavigator._clear();
+            }
+            if (oldRenderType === 'Card') {
+                this.quickViewNavigator._clear();
+                if (initialViewId !== undefined) {
+                    this.quickViewNavigator.push(initialViewId, true);
+                }
+            }
+            this._renderType = newRenderType;
+            this.onRenderTypeChanged(oldRenderType);
+        }
+    }
+    /**
+   * This function updates property pane configurable fields on base adaptive card extension
+   *
+   * @param path - property pane path that specifies which field to update
+   * @param value - new value to update the field with
+   *
+   * @internal
+   */ _updateConfigurableFields(path, value) {
+        switch(path){
+            case 'cardSize':
+                this._cardSize = value;
+                break;
+        }
+    }
+    /**
+   * Tracks Adaptive Card Extension card action.
+   *
+   * @param actionType - Type of action performed
+   * @param location - See {@link @microsoft/sp-webpart-base#IWebPartManagerContext.PageHostLayoutType}.
+   * @param mobileSessionId - mobile session id
+   * @param mobileBootType - mobile boot type
+   *
+   * @internal
+   */ _logCardActionEngagement(actionType, location, mobileSessionId, mobileBootType, componentName) {
+        const engagementData = this._getBaseEngagementData(location, !isSurfaceOnBeforeActionKSActivated() ? this.renderType : actionType === 'QuickView' ? 'Card' : this.renderType, mobileSessionId, mobileBootType);
+        engagementData.name = ADAPTIVECARDEXTENSION_CARDACTION;
+        engagementData.isIntentional = true;
+        let loggedActionType = actionType;
+        if (actionType === 'ExternalLink') {
+            loggedActionType = 'OpenUrl';
+        } else if (!isLogExecuteAsSubmitActionKSActivated() && actionType === 'Execute') {
+            loggedActionType = 'Submit';
+        }
+        engagementData.extraData.actionType = loggedActionType;
+        engagementData.extraData.componentName = componentName;
+        this._logEngagement(engagementData);
+    }
+    /**
+   * Tracks Adaptive Card Extension components' events, such as text input onChange.
+   *
+   * @param componentName - Name of the component (unique name of the component)
+   * @param eventName - Name of the event
+   * @param location - See {@link @microsoft/sp-webpart-base#IWebPartManagerContext.PageHostLayoutType}.
+   * @param mobileSessionId - mobile session id
+   * @param mobileBootType - mobile boot type
+   *
+   * @internal
+   */ _logCardComponentEventEngagement(componentName, eventName, location, mobileSessionId, mobileBootType) {
+        const engagementData = this._getBaseEngagementData(location, 'Card', mobileSessionId, mobileBootType);
+        engagementData.name = ADAPTIVECARDEXTENSION_COMPONENTEVENT;
+        engagementData.isIntentional = true;
+        engagementData.extraData.componentName = componentName;
+        engagementData.extraData.eventName = eventName;
+        engagementData.extraData.isCurrentSiteAHomeSite = this.context.pageContext?.legacyPageContext?.isCurrentSiteAHomeSite;
+        engagementData.extraData.isCurrentSiteAVivaBackendSite = this.context.pageContext?.legacyPageContext?.isCurrentSiteAVivaBackendSite;
+        this._logEngagement(engagementData);
+    }
+    /**
+   * @internal
+   */ _initializeCardView(view) {
+        this._initializeBaseView(view);
+        view._getCardSize = ()=>this.cardSize;
+    }
+    /**
+   * @internal
+   */ _initializeBaseView(view) {
+        view._state = this.state;
+        view._ace = this;
+        view._properties = this.properties;
+        view._context = this.context;
+    }
+    /**
+   *
+   * @internal
+   * @returns boolean representing whether ACE should have nonreactive property pane
+   *
+   */ get _disableReactivePropertyChanges() {
+        return false;
+    }
+    /**
+   *
+   * @internal
+   * @returns promise of generic properties of ACE
+   * Used when ACE utilizes a nonreactive property pane and has to apply changes asynchronously
+   */ _onPropertyPaneChangesApplied() {
+        return Promise.resolve();
+    }
+    /**
+   *
+   * @internal
+   * Method that is called once property changes were applied asynchronously
+   * Used with a nonreactive property pane
+   */ _onAfterPropertyPaneChangesApplied() {
+    //empty block
+    }
+    /**
+   * Returns the AdaptiveCard payload (template and data), as well as the top PageBar's configuration properties
+   *
+   * @param updateOnlyData - boolean
+   */ _getQuickView(updateOnlyData) {
+        if (this.quickViewNavigator.size === 0) {
+            return undefined;
+        }
+        const currentView = this.quickViewNavigator._currentView instanceof BaseQuickView ? this.quickViewNavigator._currentView : this.quickViewNavigator._currentView?.view;
+        if (currentView === undefined) {
+            return undefined;
+        }
+        const viewType = currentView._viewType;
+        if (this._previousQuickViewId !== this.quickViewNavigator.currentId) {
+            _EngagementLogger.log({
+                name: 'AdaptiveCardExtension.QuickView',
+                isIntentional: true,
+                siteId: this.context.pageContext?.site?.id.toString(),
+                webId: this.context.pageContext?.web?.id.toString(),
+                extraData: {
+                    alias: this.manifest.alias,
+                    appHostType: this._appHostType,
+                    correlationId: this.context.pageContext?.site?.correlationId?.toString(),
+                    deviceContext: this.context.deviceContext,
+                    instanceId: this._instanceIdForLogs,
+                    quickViewType: viewType,
+                    tenantId: this.context.pageContext?.aadInfo?.tenantId?.toString().toLowerCase(),
+                    ...!isLogBotIdAndTeamsConnectedAppIdKSActivated() ? {
+                        botId: this.manifest.properties?.botId,
+                        connectedTeamsAppId: this.manifest.connectedTeamsAppId
+                    } : {}
+                }
+            });
+        }
+        this._previousQuickViewId = this.quickViewNavigator.currentId;
+        const pageBarProperties = {
+            externalLink: currentView.externalLink,
+            leftNavigationButtonType: this.quickViewNavigator.size > 1 ? 'Back' : 'Close',
+            title: currentView.title
+        };
+        if (viewType === 'WebQuickView') {
+            return {
+                render: this._assignAndRenderWebQuickView,
+                dispose: this._disposeWebQuickView.bind(this, currentView),
+                pageBarProperties,
+                viewId: this.quickViewNavigator.currentId,
+                viewStackSize: this.quickViewNavigator.size,
+                quickViewType: 'WebQuickView'
+            };
+        } else {
+            const acQuickView = currentView;
+            let focusParameters = acQuickView.focusParameters;
+            if (!(this.quickViewNavigator._currentView instanceof BaseQuickView)) {
+                focusParameters = acQuickView.focusParameters !== undefined ? {
+                    ...acQuickView.focusParameters,
+                    _lastFocusedElement: this.quickViewNavigator._currentView.focusElement
+                } : {
+                    focusTarget: undefined,
+                    _lastFocusedElement: this.quickViewNavigator._currentView.focusElement
+                };
+            }
+            return {
+                data: acQuickView.data,
+                template: updateOnlyData ? this._ACRenderArgs.quickLook.template : acQuickView.template,
+                pageBarProperties,
+                viewId: this.quickViewNavigator.currentId,
+                viewStackSize: this.quickViewNavigator.size,
+                focusParameters: focusParameters,
+                quickViewType: 'AdaptiveCardQuickView'
+            };
+        }
+    }
+    /**
+   * Updates this._cardObject fields according to type given
+   * If RenderType is
+   * 'L1' then call getL1 will be invoked. This will be used internally to support first time render
+   * 'L2' and updateOnlyData == false, then getL2Template and getL2Data will be invoked
+   * 'L2' and updateOnlyData == true, then getL2Data will be invoked and the last known template will be reused
+   * @param renderTypeToUpdate - RenderType
+   * @param updateOnlyData - boolean
+   */ _updateRenderArgs(renderTypeToUpdate, updateOnlyData) {
+        this._ACRenderArgs.lastUpdatedType = renderTypeToUpdate;
+        this._ACRenderArgs.isVisible = this._isVisible;
+        if (isDashboardCardDeeplinkingKSActivated() || isUpdateCardViewForQVRenderTypeKSActivated()) {
+            if (renderTypeToUpdate === 'Card') {
+                this._ACRenderArgs.card = this._getCard(updateOnlyData);
+            } else {
+                this._ACRenderArgs.quickLook = this._getQuickView(updateOnlyData);
+            }
+        } else {
+            this._ACRenderArgs.card = this._getCard(updateOnlyData);
+            if (renderTypeToUpdate === 'QuickView') {
+                this._ACRenderArgs.quickLook = this._getQuickView(updateOnlyData);
+            }
+        }
+    }
+    _updateProperty(path, value) {
+        update(this._properties, path, ()=>value);
+    }
+    /**
+   * Start renderComplete guard timer.
+   * If renderComplete API is not called within DEFAULT_ASYNC_RENDER_COMPLETED_TIMEOUT_TIME seconds,
+   * it will automatically invoke renderComplete as a time out.
+   *
+   * Note: Timer guard exist because BaseClientSideWebpart have a 30 second timer guard.
+   * This accounts for isolated ace scenario where it has to create the isolated domain and load the ace in it.
+   *
+   */ _startRenderCompletedGuardTimer() {
+        this._renderCompletedPromise = new Promise((resolve, reject)=>{
+            this._renderCompletedPromiseResolver = resolve;
+            this._renderCompletedPromiseRejector = reject;
+        });
+        this._renderCompletedGuardTimer = window.setTimeout(()=>{
+            this._renderCompletedPromiseRejector();
+        }, !isReduceRenderTimeoutKSActivated() ? UPDATED_ASYNC_RENDER_COMPLETED_TIMEOUT_TIME : DEFAULT_ASYNC_RENDER_COMPLETED_TIMEOUT_TIME);
+        this._resolveRenderCompleted();
+    }
+    _clearRenderCompletedGuardTimer() {
+        if (this._renderCompletedGuardTimer) {
+            window.clearTimeout(this._renderCompletedGuardTimer);
+            this._renderCompletedGuardTimer = undefined;
+            this._renderCompletedPromiseResolver = undefined;
+            this._renderCompletedPromiseRejector = undefined;
+            this._renderCompletedPromise = undefined;
+        }
+    }
+    _generateCacheKey(dashboardWebPartInstanceId) {
+        if (!this.mySiteCacheEnabled || this.context.deviceContext === 'Mobile' || this.context.manifest.isolatedDomain) {
+            return LocalStorageACECache.getKey(this.siteId, this.itemId);
+        } else {
+            return dashboardWebPartInstanceId ?? this.instanceId;
+        }
+    }
+    _logInternalOnActionError(error, failureTag) {
+        const qosMonitor = new _QosMonitor('AdaptiveCardExtension._internalOnAction');
+        qosMonitor.writeUnexpectedFailure(failureTag, error, {
+            alias: this.context.manifest.alias,
+            deviceContext: this.context.deviceContext,
+            instanceId: this.instanceId,
+            isInternal: this.manifest.isInternal || false,
+            manifestId: this.context.manifest.id,
+            displayMode: this.displayMode
+        });
+    }
+    _beginUpdate() {
+        this._isUpdating = true;
+    }
+    _endUpdate() {
+        this._isUpdating = false;
+    }
+    _getBaseEngagementData(location, renderType, mobileSessionId, mobileBootType) {
+        const cardPositionData = {};
+        if (this.context._getPositionOnPage) {
+            const cardPositionInfo = this.context._getPositionOnPage();
+            if (cardPositionInfo) {
+                cardPositionData.cardPosition = cardPositionInfo.componentOrder;
+                cardPositionData.NumberOfCardsAudienceTargeted = cardPositionInfo.numberOfSectionComponents;
+            }
+        }
+        let listItemUniqueId;
+        if (!isEnableDashboardUniqueIdInEngagementLogsEnabled()) {
+            listItemUniqueId = this._urlParams.get('id') ? this._urlParams.get('id') : this.context.pageContext.listItem?.id;
+        } else {
+            // Dashboard.aspx SP page -- this.context.pageContext.listItem?.uniqueId
+            // vivahome.aspx && VC dashboard webpart -- this._dashboardUniqueId, injected via dashboard webpart
+            listItemUniqueId = this._dashboardUniqueId || this.context.pageContext.listItem?.uniqueId || '';
+        }
+        return {
+            siteId: this.context.pageContext?.site?.id.toString(),
+            webId: this.context.pageContext?.web?.id.toString(),
+            extraData: {
+                alias: this.manifest.alias,
+                appHostType: this._appHostType,
+                cardSize: this.cardSize,
+                componentDeveloperName: this.manifest.componentDeveloperName,
+                correlationId: this.context.pageContext?.site?.correlationId?.toString(),
+                deviceContext: this.context.deviceContext,
+                eventSchemaVersion: 10,
+                isInternal: this.manifest.isInternal || false,
+                instanceId: this._instanceIdForLogs,
+                listId: this._urlParams.get('dashboardListID') ? this._urlParams.get('dashboardListID') : this.context.pageContext.list?.id.toString(),
+                listItemUniqueId: listItemUniqueId,
+                manifestId: this.manifest.id,
+                mobileSessionId: mobileSessionId,
+                mobileBootType: mobileBootType,
+                mpnId: this.manifest.mpnId,
+                renderType: renderType,
+                tenantId: this.context.pageContext?.aadInfo?.tenantId?.toString().toLowerCase(),
+                vivaConnectionsAppId: VIVA_CONNECTIONS_APP_ID,
+                vivaConnectionsName: VIVA_CONNECTIONS_NAME,
+                workLoad: location,
+                isCurrentSiteAHomeSite: this.context.pageContext?.legacyPageContext?.isCurrentSiteAHomeSite,
+                isCurrentSiteAVivaBackendSite: this.context.pageContext?.legacyPageContext?.isCurrentSiteAVivaBackendSite,
+                templateType: this.cardNavigator._currentView instanceof BaseCardView ? this.cardNavigator._currentView._templateType : this.cardNavigator._currentView.view._templateType,
+                ...cardPositionData,
+                ...!isLogEngagementExtraDataKSActivated() ? this._cardActionEngagementExtraData : {},
+                ...!isLogBotIdAndTeamsConnectedAppIdKSActivated() ? {
+                    botId: this.manifest.properties?.botId,
+                    connectedTeamsAppId: this.manifest.connectedTeamsAppId
+                } : {}
+            }
+        };
+    }
+    _logEngagement(engagementData) {
+        _EngagementLogger.log(engagementData);
+    }
+    constructor(){
+        super();
+        this._isLoggedRenderPerf = false;
+        // Set to true after onInit is called by the loader
+        this._isInitialized = false;
+        this._isInitializedWithLKG = false;
+        /**
+   * Not over-engineering now, but we can change the type to number in future if we want to support nested beginUpdate...endUpdate.
+   */ this._isUpdating = false;
+        // #endregion
+        // #region Private
+        this._getCard = (updateOnlyData)=>{
+            try {
+                return getCardRenderParameters(this.cardNavigator._currentView instanceof BaseCardView ? this.cardNavigator._currentView : this.cardNavigator._currentView.view, this.cardSize, this.context.deviceContext, updateOnlyData ? this._ACRenderArgs.card.template : undefined, this.iconProperty, this.title, this.manifest, this.instanceId, this.cardNavigator.currentId);
+            } catch (error) {
+                this.context._host.onError(error.toString());
+                throw error;
+            }
+        };
+        this._assignAndRenderWebQuickView = (domElement)=>{
+            const currentView = this.quickViewNavigator._currentView instanceof BaseQuickView ? this.quickViewNavigator._currentView : this.quickViewNavigator._currentView?.view;
+            const monitor = new _QosMonitor('ACE.WebQuickView.Render');
+            try {
+                if (currentView === undefined || currentView._viewType === 'AdaptiveCardQuickView') {
+                    monitor.writeExpectedFailure('IncorrectQVType', undefined, {
+                        viewType: currentView._viewType
+                    });
+                    return;
+                }
+                currentView._setDomElement(domElement);
+                currentView.render();
+                monitor.writeSuccess();
+            } catch (err) {
+                monitor.writeUnexpectedFailure('FailedToRender', err);
+            }
+        };
+        /**
+   * Quick view navigator will modify the stack when navigating between different quick views.
+   * Bind currentView argument to the function when using this method.
+   */ this._disposeWebQuickView = (currentView)=>{
+            const monitor = new _QosMonitor('ACE.WebQuickView.Dispose');
+            try {
+                if (currentView === undefined || currentView._viewType === 'AdaptiveCardQuickView') {
+                    monitor.writeExpectedFailure('IncorrectQVType', undefined, {
+                        viewType: currentView._viewType
+                    });
+                    return;
+                }
+                currentView.dispose();
+                // remove dom element after view has been disposed.
+                currentView._setDomElement(undefined);
+                monitor.writeSuccess();
+            } catch (err) {
+                monitor.writeUnexpectedFailure('FailedToDispose', err);
+            }
+        };
+        this._onViewInitialized = (view)=>{
+            this._initializeCardView(view);
+        };
+        this._onQuickViewInitialized = (view)=>{
+            this._initializeBaseView(view);
+        };
+        this._navigatorCallback = (skipUpdate)=>{
+            if (!skipUpdate) {
+                this.update(this._renderType);
+            }
+        };
+        this._closeQuickViewCallback = ()=>{
+            this.context._host.requestRenderTypeChange('Card', this.instanceId);
+        };
+        this._cardSize = DEFAULT_CARD_SIZE;
+        this._renderType = 'Card';
+        this._isVisible = true;
+        this._urlParams = new URLSearchParams(window.location.search);
+    }
+}
+_ES5CompatibleClass(BaseAdaptiveCardExtension);
+
+//# sourceMappingURL=./BaseAdaptiveCardExtension.js.map