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

package/{lib → lib-esm}/isolation/RenderArgumentsUtils.js

@@ -1,4 +1,3 @@
-import { __assign } from "tslib";
 import { cloneDeep } from '@microsoft/sp-lodash-subset';
 import { generateComponentId } from '../components/BaseComponent';
 import { _QosMonitor } from '@microsoft/sp-diagnostics';
@@ -7,76 +6,83 @@ import { isCorrectlyStripRenderParametersKSActivated, isKeyboardFocusViewNavChan
  * Prepares render arguments for messaging scenarios such as VCM and Bot ACE.
  *
  * @internal
- */
-export function prepareRenderArgumentsForMessaging(renderArguments) {
-    var _a, _b, _c, _d;
+ */ export function prepareRenderArgumentsForMessaging(renderArguments) {
     // the monitor is used to track the performance of this function
-    var qosMonitor = new _QosMonitor('AdaptiveCardExtension.prepareRenderArgumentsForMessaging');
+    const qosMonitor = new _QosMonitor('AdaptiveCardExtension.prepareRenderArgumentsForMessaging');
     if (!isCorrectlyStripRenderParametersKSActivated()) {
         //
         // corrected flow: we need to process quick view if there is quickLook property; card view if there is a card property - INDEPENDENTLY of lastUpdatedType
         //
-        var quickView = renderArguments.quickLook;
-        var card = renderArguments.card;
-        var eventComponents = void 0;
+        let quickView = renderArguments.quickLook;
+        const card = renderArguments.card;
+        let eventComponents;
         if (quickView) {
             if (quickView.quickViewType === 'AdaptiveCardQuickView') {
                 // AC Quick View
-                var acQVRenderParemeters = quickView;
-                if (!isKeyboardFocusViewNavChangesKSActivated() &&
-                    ((_a = acQVRenderParemeters.focusParameters) === null || _a === void 0 ? void 0 : _a._lastFocusedElement)) {
+                const acQVRenderParemeters = quickView;
+                if (!isKeyboardFocusViewNavChangesKSActivated() && acQVRenderParemeters.focusParameters?._lastFocusedElement) {
                     // we need to remove lastFocusedElement
-                    quickView = __assign(__assign({}, acQVRenderParemeters), { focusParameters: __assign(__assign({}, acQVRenderParemeters.focusParameters), { _lastFocusedElement: undefined }) });
+                    quickView = {
+                        ...acQVRenderParemeters,
+                        focusParameters: {
+                            ...acQVRenderParemeters.focusParameters,
+                            _lastFocusedElement: undefined
+                        }
+                    };
                 }
-            }
-            else {
+            } else {
                 // Web Quick View
                 quickView = _prepareWebQuickViewForMessaging(quickView);
             }
         }
         if (card) {
             // processing card view
-            var _e = _prepareCardViewForMessaging(card.cardViewParameters, renderArguments.instanceId), cardViewParameters = _e[0], cardViewEventComponents = _e[1];
+            const [cardViewParameters, cardViewEventComponents] = _prepareCardViewForMessaging(card.cardViewParameters, renderArguments.instanceId);
             card.cardViewParameters = cardViewParameters;
             eventComponents = cardViewEventComponents;
         }
         qosMonitor.writeSuccess({
-            viewType: renderArguments.lastUpdatedType === 'QuickView'
-                ? quickView.quickViewType
-                : card.cardViewParameters.cardViewType
+            viewType: renderArguments.lastUpdatedType === 'QuickView' ? quickView.quickViewType : card.cardViewParameters.cardViewType
         });
         return {
-            renderArguments: __assign(__assign({}, renderArguments), { quickLook: quickView, card: card }),
-            eventComponents: eventComponents
+            renderArguments: {
+                ...renderArguments,
+                quickLook: quickView,
+                card
+            },
+            eventComponents
         };
-    }
-    else {
-        if ((renderArguments.lastUpdatedType === 'QuickView' &&
-            (isPrepareHTMLQVForMessagingKSActivated() ||
-                ((_b = renderArguments.quickLook) === null || _b === void 0 ? void 0 : _b.quickViewType) === 'AdaptiveCardQuickView')) ||
-            !((_c = renderArguments.card) === null || _c === void 0 ? void 0 : _c.cardViewParameters)) {
-            var acQVRenderParemeters = renderArguments.quickLook;
-            if (!isKeyboardFocusViewNavChangesKSActivated() &&
-                ((_d = acQVRenderParemeters.focusParameters) === null || _d === void 0 ? void 0 : _d._lastFocusedElement)) {
+    } else {
+        if (renderArguments.lastUpdatedType === 'QuickView' && (isPrepareHTMLQVForMessagingKSActivated() || renderArguments.quickLook?.quickViewType === 'AdaptiveCardQuickView') || !renderArguments.card?.cardViewParameters) {
+            const acQVRenderParemeters = renderArguments.quickLook;
+            if (!isKeyboardFocusViewNavChangesKSActivated() && acQVRenderParemeters.focusParameters?._lastFocusedElement) {
                 // we need to remove lastFocusedElement
                 return {
-                    renderArguments: __assign(__assign({}, renderArguments), { quickLook: __assign(__assign({}, acQVRenderParemeters), { focusParameters: __assign(__assign({}, acQVRenderParemeters.focusParameters), { _lastFocusedElement: undefined }) }) })
+                    renderArguments: {
+                        ...renderArguments,
+                        quickLook: {
+                            ...acQVRenderParemeters,
+                            focusParameters: {
+                                ...acQVRenderParemeters.focusParameters,
+                                _lastFocusedElement: undefined
+                            }
+                        }
+                    }
                 };
             }
             return {
-                renderArguments: renderArguments
+                renderArguments
             };
         }
-        var viewType = void 0;
-        var eventComponents = void 0;
+        let viewType;
+        let eventComponents;
         if (renderArguments.lastUpdatedType === 'QuickView') {
             // processing Web QV
             renderArguments.quickLook = _prepareWebQuickViewForMessaging(renderArguments.quickLook);
             viewType = renderArguments.quickLook.quickViewType;
-        }
-        else {
+        } else {
             // processing card view
-            var _f = _prepareCardViewForMessaging(renderArguments.card.cardViewParameters, renderArguments.instanceId), cardViewParameters = _f[0], cardViewEventComponents = _f[1];
+            const [cardViewParameters, cardViewEventComponents] = _prepareCardViewForMessaging(renderArguments.card.cardViewParameters, renderArguments.instanceId);
             renderArguments.card.cardViewParameters = cardViewParameters;
             eventComponents = cardViewEventComponents;
             viewType = cardViewParameters.cardViewType;
@@ -85,8 +91,8 @@ export function prepareRenderArgumentsForMessaging(renderArguments) {
             viewType: viewType
         });
         return {
-            renderArguments: renderArguments,
-            eventComponents: eventComponents
+            renderArguments,
+            eventComponents
         };
     }
 }
@@ -94,21 +100,19 @@ export function prepareRenderArgumentsForMessaging(renderArguments) {
  * Gets render arguments for messaging scenarios such as VCM and Bot ACE.
  *
  * @internal
- */
-export function getRenderArgumentsForMessaging(ace, renderType) {
-    var _a;
-    var renderArguments = ace._getRenderArguments(renderType);
-    if (renderType !== 'Card' || !((_a = renderArguments.card) === null || _a === void 0 ? void 0 : _a.cardViewParameters)) {
+ */ export function getRenderArgumentsForMessaging(ace, renderType) {
+    const renderArguments = ace._getRenderArguments(renderType);
+    if (renderType !== 'Card' || !renderArguments.card?.cardViewParameters) {
         return {
-            renderArguments: renderArguments
+            renderArguments
         };
     }
     return prepareRenderArgumentsForMessaging(renderArguments);
 }
 function _prepareWebQuickViewForMessaging(webQuickViewRenderArguments) {
-    var clonedArguments = cloneDeep(webQuickViewRenderArguments);
-    var clonedArgumentsObject = clonedArguments;
-    Object.keys(clonedArgumentsObject).forEach(function (key) {
+    const clonedArguments = cloneDeep(webQuickViewRenderArguments);
+    const clonedArgumentsObject = clonedArguments;
+    Object.keys(clonedArgumentsObject).forEach((key)=>{
         if (typeof clonedArgumentsObject[key] === 'function') {
             delete clonedArgumentsObject[key];
         }
@@ -117,38 +121,43 @@ function _prepareWebQuickViewForMessaging(webQuickViewRenderArguments) {
 }
 function _prepareCardViewForMessaging(originalCardViewParameters, instanceId) {
     // collecting event handlers
-    var handledEvents = _getEventHandlers(originalCardViewParameters);
+    const handledEvents = _getEventHandlers(originalCardViewParameters);
     if (!handledEvents) {
-        return [originalCardViewParameters, undefined];
+        return [
+            originalCardViewParameters,
+            undefined
+        ];
     }
     // We need to clone the parameters because we don't want to modify the original object.
-    var cardViewParameters = cloneDeep(originalCardViewParameters);
-    var body = cardViewParameters.body, footer = cardViewParameters.footer;
-    var eventComponents = new Map();
+    const cardViewParameters = cloneDeep(originalCardViewParameters);
+    const { body, footer } = cardViewParameters;
+    const eventComponents = new Map();
     _prepareCardPartForMessaging(instanceId, 'body', body, originalCardViewParameters.body, handledEvents.body, eventComponents);
     _prepareCardPartForMessaging(instanceId, 'footer', footer, originalCardViewParameters.footer, handledEvents.footer, eventComponents);
-    return [cardViewParameters, eventComponents];
+    return [
+        cardViewParameters,
+        eventComponents
+    ];
 }
 /**
  * Prepares the card view part (such as body, footer, etc.) for messaging.
  * If there are any event handlers, we will return them back (as they're stripped in serialzation) and propagate id and _events properties to communicate the events back.
- */
-function _prepareCardPartForMessaging(instanceId, cardViewPart, components, originalComponents, handledEvents, eventComponents) {
+ */ function _prepareCardPartForMessaging(instanceId, cardViewPart, components, originalComponents, handledEvents, eventComponents) {
     if (!components || !handledEvents) {
         return;
     }
-    components.forEach(function (component, index) {
-        var componentHandledEvents = handledEvents[index];
+    components.forEach((component, index)=>{
+        const componentHandledEvents = handledEvents[index];
         if (!componentHandledEvents) {
             return;
         }
         //
         // After graduating d2cb3786-200c-408f-a646-6d091eadc1be id will be already there, so we don't need to generate it.
         //
-        var componentId = generateComponentId(instanceId, cardViewPart, component, index);
+        const componentId = generateComponentId(instanceId, cardViewPart, component, index);
         component.id = componentId;
         component._events = componentHandledEvents;
-        componentHandledEvents.forEach(function (eventName) {
+        componentHandledEvents.forEach((eventName)=>{
             delete component[eventName];
         });
         eventComponents.set(componentId, originalComponents[index]);
@@ -156,10 +165,9 @@ function _prepareCardPartForMessaging(instanceId, cardViewPart, components, orig
 }
 /**
  * Collects all event handlers (names of handled events) from the card view parameters.
- */
-function _getEventHandlers(cardViewParameters) {
-    var bodyEventHandlers = _getCardPartEventHandlers(cardViewParameters.body);
-    var footerEventHandlers = _getCardPartEventHandlers(cardViewParameters.footer);
+ */ function _getEventHandlers(cardViewParameters) {
+    const bodyEventHandlers = _getCardPartEventHandlers(cardViewParameters.body);
+    const footerEventHandlers = _getCardPartEventHandlers(cardViewParameters.footer);
     if (!bodyEventHandlers && !footerEventHandlers) {
         return undefined;
     }
@@ -170,18 +178,17 @@ function _getEventHandlers(cardViewParameters) {
 }
 /**
  * Collects all event handlers (functions) from the card part (such as body, footer, etc.).
- */
-function _getCardPartEventHandlers(cardPart) {
+ */ function _getCardPartEventHandlers(cardPart) {
     // array with undefined values is more performant that Map with integer keys
     // we also can't use compoents' ids here as they are optional
     if (!cardPart) {
         return undefined;
     }
-    var hasHandlers = false;
-    var handlers = cardPart.map(function (component) {
-        var componentObject = component;
-        var eventHandlers;
-        Object.keys(component).forEach(function (key) {
+    let hasHandlers = false;
+    const handlers = cardPart.map((component)=>{
+        const componentObject = component;
+        let eventHandlers;
+        Object.keys(component).forEach((key)=>{
             if (typeof componentObject[key] === 'function') {
                 if (!eventHandlers) {
                     eventHandlers = [];
@@ -197,4 +204,5 @@ function _getCardPartEventHandlers(cardPart) {
     }
     return handlers;
 }
-//# sourceMappingURL=RenderArgumentsUtils.js.map
+
+//# sourceMappingURL=./RenderArgumentsUtils.js.map

package/{lib → lib-esm}/isolation/interfaces/IBot.js

@@ -2,6 +2,6 @@
  * An instance of a Bot associated with a Bot-Driven ACE
  *
  * @internal
- */
-export {};
-//# sourceMappingURL=IBot.js.map
+ */ export { };
+
+//# sourceMappingURL=./IBot.js.map

package/lib-esm/isolation/interfaces/IIsolatedAction.js

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IIsolatedAction.js.map

package/lib-esm/isolation/interfaces/IIsolatedListener.js

@@ -0,0 +1,7 @@
+/**
+ * Information needed for an isolated listener.
+ *
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IIsolatedListener.js.map

package/lib-esm/isolation/interfaces/IIsolatedServiceCallbackParameters.js

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IIsolatedServiceCallbackParameters.js.map

package/lib-esm/isolation/interfaces/ILoadIsolatedAdaptiveCardExtensionParameters.js

@@ -0,0 +1,7 @@
+/**
+ * Set of properties needed to load an isolated Adaptive Card Extension.
+ *
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./ILoadIsolatedAdaptiveCardExtensionParameters.js.map

package/lib-esm/isolation/interfaces/IRenderIsolatedQuickViewParameters.js

@@ -0,0 +1,10 @@
+/**
+ * Properties needed to render a quick view for an isolated Adaptive Card Extension.
+ *
+ * @remarks Since this API is internal we don't define explicitly what `pageTheme` and `theme`
+ *   are. However, since the same object is used between the isolated iframe and the parent then there is an
+ *   implicit guaranteed coupling.
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IRenderIsolatedQuickViewParameters.js.map

package/lib-esm/isolation/interfaces/IsolatedAdaptiveCardExtensionApplicationMessageEvent.js

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IsolatedAdaptiveCardExtensionApplicationMessageEvent.js.map

package/lib-esm/isolation/interfaces/IsolatedServiceMessageEvent.js

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IsolatedServiceMessageEvent.js.map

package/lib-esm/test-api/AdaptiveCardExtensionTestWrapper.js

@@ -0,0 +1,125 @@
+import { DisplayMode, ServiceScope } from '@microsoft/sp-core-library';
+import { AdaptiveCardExtensionContext, _AdaptiveCardExtensionHost, BaseCardView, BaseQuickView } from '../index';
+import MockAdaptiveCardExtensionManifestInstance from './MockAdaptiveCardExtensionManifestInstance';
+const TEST_TAG_NAME = 'AdaptiveCardExtensionTestWrapper';
+const KEY = '95720abe-cc9f-43e6-8a23-4cb82daaddf2-dd4e95e6-7260-40c5-8e93-aff785ceeb6b';
+/**
+ * A wrapper class around ACEs that allows a developer to test the full lifecycle of an AdaptiveCardExtension in unit tests
+ *
+ * Exposes functionality that is normally handled internally or by a renderer (e.g., opening a QuickView, retrieving the current View objects, etc)
+ *
+ * Usage:
+ *
+ * const wrapper: AdaptiveCardExtensionTestWrapper<MyAdaptiveCardExtension> = new AdaptiveCardExtensionTestWrapper<MyAdaptiveCardExtension>(testData, MyAdaptiveCardExtension);
+ *
+ */ export class AdaptiveCardExtensionTestWrapper {
+    load() {
+        this._adaptiveCardExtension = new this._cls();
+        // override _generateCacheKey as it needs to read from `this.context.pageContext` which does not exist.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        jest.spyOn(this._cls.prototype, '_generateCacheKey').mockImplementation(()=>KEY);
+        this._adaptiveCardExtension._internalInitialize(this._getContext(this._testData), false, DisplayMode.Read, TEST_TAG_NAME, false, undefined);
+        this._adaptiveCardExtension._internalDeserialize(this._getData(this._testData));
+        this._host.onBeforeInitialized(this._adaptiveCardExtension);
+        return this._adaptiveCardExtension.onInit().then(()=>{
+            this._adaptiveCardExtension._internalOnAfterInit();
+            // Ensures the initial Card view is pushed to the navigator
+            this._adaptiveCardExtension._getRenderArguments('Card');
+        })// eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .catch((error)=>{
+            throw error;
+        });
+    }
+    _logCardActionEngagement(actionType, location, mobileSessionId, mobileBootType) {
+        this._adaptiveCardExtension = new this._cls();
+        this._adaptiveCardExtension._internalInitialize(this._getContext(this._testData), false, DisplayMode.Read, TEST_TAG_NAME, false, undefined);
+        Object.defineProperty(this._adaptiveCardExtension.cardNavigator._currentView instanceof BaseCardView ? this._adaptiveCardExtension.cardNavigator : this._adaptiveCardExtension.cardNavigator._currentView, this._adaptiveCardExtension.cardNavigator._currentView instanceof BaseCardView ? '_currentView' : 'view', {
+            value: 'mocked value'
+        });
+        this._adaptiveCardExtension._logCardActionEngagement(actionType, location, mobileSessionId, mobileBootType);
+    }
+    get adaptiveCardExtension() {
+        return this._adaptiveCardExtension;
+    }
+    get context() {
+        return this._context;
+    }
+    openQuickView(viewId) {
+        this._setRenderType('QuickView', viewId);
+    }
+    get currentCardView() {
+        return this._adaptiveCardExtension.cardNavigator._currentView instanceof BaseCardView ? this._adaptiveCardExtension.cardNavigator._currentView : this._adaptiveCardExtension.cardNavigator._currentView.view;
+    }
+    get currentQuickView() {
+        return this._adaptiveCardExtension.quickViewNavigator._currentView instanceof BaseQuickView ? this._adaptiveCardExtension.quickViewNavigator._currentView : this._adaptiveCardExtension.quickViewNavigator._currentView.view;
+    }
+    onNotificationReceived(notificationArguments) {
+        return this._adaptiveCardExtension.onNotificationReceived(notificationArguments);
+    }
+    _getContext(testData) {
+        const contextParams = {
+            host: this._host,
+            manifest: testData.manifest || new MockAdaptiveCardExtensionManifestInstance(),
+            instanceId: testData.instanceId || 'aceInstanceId',
+            parentServiceScope: this._rootScope,
+            loggingTag: '',
+            deviceContext: 'WebView',
+            location: ()=>{
+                return new Promise((resolve, reject)=>{
+                    return resolve({
+                        latitude: 10,
+                        longitude: 10
+                    });
+                });
+            }
+        };
+        return new AdaptiveCardExtensionContext(contextParams);
+    }
+    _getData(testData) {
+        const defaultAdaptiveCardExtensionData = {
+            dataVersion: '1.0.0',
+            id: 'aceId',
+            instanceId: 'aceInstanceId',
+            properties: {},
+            title: 'title',
+            description: 'description',
+            iconProperty: 'iconProperty',
+            cardSize: 'Medium'
+        };
+        return {
+            ...defaultAdaptiveCardExtensionData,
+            ...testData
+        };
+    }
+    constructor(testData, cls, rootScope){
+        this._onUpdateCallback = (card)=>{
+        // no-op
+        };
+        this._onVisibilityChanged = ()=>{
+        // no-op
+        };
+        this._setRenderType = (newRenderType, instanceId, initialViewId)=>{
+            if (this._renderType !== newRenderType) {
+                this._renderType = newRenderType;
+                this._adaptiveCardExtension._setRenderType(newRenderType, initialViewId);
+            }
+        };
+        this._testData = testData;
+        this._cls = cls;
+        this._host = new _AdaptiveCardExtensionHost({
+            onRequestRenderTypeCallback: this._setRenderType,
+            onUpdateCallback: this._onUpdateCallback,
+            onVisibilityChanged: this._onVisibilityChanged,
+            cache: this._testData.cache
+        });
+        this._renderType = 'Card';
+        if (rootScope) {
+            this._rootScope = rootScope;
+        } else {
+            this._rootScope = ServiceScope.startNewRoot();
+            this._rootScope.finish();
+        }
+    }
+}
+
+//# sourceMappingURL=./AdaptiveCardExtensionTestWrapper.js.map

package/{lib → lib-esm}/test-api/MockAdaptiveCardExtensionManifestInstance.js

@@ -1,13 +1,17 @@
 import { TEST_UNDEFINED } from '@microsoft/sp-core-library/dist/test-api';
-var MockAdaptiveCardExtensionManifestInstance = /** @class */ (function () {
-    function MockAdaptiveCardExtensionManifestInstance() {
+class MockAdaptiveCardExtensionManifestInstance {
+    constructor(){
         this.manifestVersion = 2;
         this.id = 'aceid';
         this.componentType = 'AdaptiveCardExtension';
         this.alias = 'MockAdaptiveCardExtension';
         this.version = '1.0.0';
-        this.title = { default: 'aceName' };
-        this.description = { default: 'aceDescription' };
+        this.title = {
+            default: 'aceName'
+        };
+        this.description = {
+            default: 'aceDescription'
+        };
         this.officeFabricIconFontName = 'aceIcon';
         this.iconImageUrl = 'aceIcon';
         this.groupId = 'group';
@@ -15,7 +19,7 @@ var MockAdaptiveCardExtensionManifestInstance = /** @class */ (function () {
         this.preconfiguredEntries = [];
         this.loaderConfig = TEST_UNDEFINED;
     }
-    return MockAdaptiveCardExtensionManifestInstance;
-}());
-export default MockAdaptiveCardExtensionManifestInstance;
-//# sourceMappingURL=MockAdaptiveCardExtensionManifestInstance.js.map
+}
+export { MockAdaptiveCardExtensionManifestInstance as default };
+
+//# sourceMappingURL=./MockAdaptiveCardExtensionManifestInstance.js.map

package/{lib → lib-esm}/test-api/index.js

@@ -1,2 +1,3 @@
 export { AdaptiveCardExtensionTestWrapper } from './AdaptiveCardExtensionTestWrapper';
-//# sourceMappingURL=index.js.map
+
+//# sourceMappingURL=./index.js.map

package/lib-esm/utilities/StringHelper.js

@@ -0,0 +1,8 @@
+const FORMAT_REGEX = /\{(\d+)\}/g;
+export function format(template, ...args) {
+    return template.replace(FORMAT_REGEX, (match, idx)=>{
+        return args[idx] === null ? '' : '' + args[idx];
+    });
+}
+
+//# sourceMappingURL=./StringHelper.js.map

package/lib-esm/views/base/BaseView.js

@@ -0,0 +1,47 @@
+import { _ES5CompatibleClass } from '@microsoft/sp-core-library';
+/**
+ * Base class for all views.
+ *
+ * @remarks No third-party views should inherit from this class.
+ *
+ * @public
+ * @sealed
+ */ export class BaseView {
+    /**
+   * See {@link BaseAdaptiveCardExtension.cardNavigator}.
+   *
+   * @readonly
+   */ get cardNavigator() {
+        return this._ace.cardNavigator;
+    }
+    /**
+   * See {@link BaseAdaptiveCardExtension.quickViewNavigator}.
+   *
+   * @readonly
+   */ get quickViewNavigator() {
+        return this._ace.quickViewNavigator;
+    }
+    /**
+   * See {@link BaseAdaptiveCardExtension.properties}.
+   */ get properties() {
+        return this._properties;
+    }
+    /**
+   * See {@link BaseAdaptiveCardExtension.state}.
+   */ get state() {
+        return this._state;
+    }
+    /**
+   * See {@link BaseAdaptiveCardExtension.context}.
+   */ get context() {
+        return this._context;
+    }
+    /**
+   * See {@link BaseAdaptiveCardExtension.setState}.
+   */ setState(newState) {
+        this._ace.setState(newState);
+    }
+}
+_ES5CompatibleClass(BaseView);
+
+//# sourceMappingURL=./BaseView.js.map

package/lib-esm/views/card/BaseBasicCardView.js

@@ -0,0 +1,51 @@
+import { _ES5CompatibleClass } from '@microsoft/sp-core-library';
+import { basicL1Template } from '../../ac-template/basicL1Template';
+import { basicL1TemplateSelectAction } from '../../ac-template/basicL1TemplateSelectAction';
+import { BaseTemplateCardView } from './BaseTemplateCardView';
+import { BasicCardView } from './parameters/GenericTemplates';
+/**
+ * Base class for a Basic Card view.
+ *
+ * @remarks The basic Card view displays the following:
+ *  - Card title
+ *  - Card icon
+ *  - One primary text field
+ *  - One button in the `Medium` Card size, two buttons in the `Large` Card size
+ *
+ * @public
+ */ export class BaseBasicCardView extends BaseTemplateCardView {
+    /**
+   * @internal
+   */ _getCardViewParameters() {
+        const data = this.data;
+        const parameters = BasicCardView({
+            cardBar: this._getCardBarConfiguration(),
+            header: {
+                componentName: 'text',
+                text: data.primaryText
+            },
+            footer: this._getGenericCardViewFooterConfiguration()
+        });
+        // updating the cardViewType to track "old" templates
+        parameters.cardViewType = 'basic-template';
+        return parameters;
+    }
+    /**
+   * Returns the Adaptive Card template for the {@link BaseBasicCardView}.
+   *
+   * @public
+   * @sealed
+   * @deprecated template property is deprecated for card views.
+   */ get template() {
+        return this._getTemplate(basicL1Template, basicL1TemplateSelectAction);
+    }
+    constructor(...args){
+        super(...args);
+        /**
+   * @internal
+   */ this._templateType = 'Basic';
+    }
+}
+_ES5CompatibleClass(BaseBasicCardView);
+
+//# sourceMappingURL=./BaseBasicCardView.js.map

package/lib-esm/views/card/BaseCardView.js

@@ -0,0 +1,59 @@
+import { _ES5CompatibleClass } from '@microsoft/sp-core-library';
+import { BaseView } from '../base/BaseView';
+/**
+ * Primitive base class for Card views.
+ *
+ * @remarks No third-party Card views should inherit from this class.
+ *
+ * @public
+ * @sealed
+ */ export class BaseCardView extends BaseView {
+    /**
+   * See {@link BaseAdaptiveCardExtension.cardSize}.
+   */ get cardSize() {
+        return this._getCardSize();
+    }
+    /**
+   * Sets visibility to false and rerenders the card.
+   * See {@link BaseAdaptiveCardExtension.isVisible}.
+   */ setVisibility(isVisible) {
+        this._ace.isVisible = isVisible;
+    }
+    /**
+   * Action to invoke when the card is selected.
+   *
+   * @virtual
+   */ get onCardSelection() {
+        return undefined;
+    }
+    /**
+   * If true, this Card view will be cached and rendered at next load.
+   *
+   * @virtual
+   */ get isCacheEnabled() {
+        return true;
+    }
+    /**
+   * Action handler for Adaptive Card Actions.
+   *
+   * @param action - The {@link IActionArguments} for the current event.
+   *
+   * @virtual
+   */ onAction(action) {
+    // no-op
+    }
+    /**
+   * @beta
+   *
+   * Error handler for Adaptive Card Actions.
+   *
+   * @param error - The {@link IActionErrorArguments} for the current event.
+   *
+   * @virtual
+   */ onActionError(error) {
+    // no-op
+    }
+}
+_ES5CompatibleClass(BaseCardView);
+
+//# sourceMappingURL=./BaseCardView.js.map