@microsoft/sp-component-base 1.22.0-beta.2 → 1.22.0-beta.4

package/dist/467dc675-7cc5-4709-8aac-78e3b71bd2f6.manifest.json

@@ -319,7 +319,7 @@
       "@msinternal/sp-telemetry": {
         "type": "component",
         "id": "8217e442-8ed3-41fd-957d-b112e841286a",
-        "version": "0.35.36"
+        "version": "0.35.55"
       }
     }
   }

package/lib/BaseComponent.d.ts

@@ -0,0 +1,115 @@
+import type { ServiceScope, ISPEventObserver } from '@microsoft/sp-core-library';
+import type { IClientSideComponentManifest } from '@microsoft/sp-module-interfaces';
+import type BaseComponentContext from './BaseComponentContext';
+/**
+ * The base class for client-side components such as BaseClientSideWebPart or BaseExtension.
+ *
+ * @public
+ */
+export default abstract class BaseComponent implements ISPEventObserver {
+    /**
+     * Use the context object to access common services and state associated with the component.
+     *
+     * @remarks
+     *
+     * Child classes are expected to override this field by redeclaring it with a specialized type.
+     * It is meant to be a read-only property; the type cannot be declared as read-only in the base class
+     * (because it is initialized outside the constructor), but child classes should redeclare
+     * it as readonly.
+     *
+     * @privateRemarks
+     *
+     * This is a workaround for a missing compiler feature.  If the compiler issue is resolved,
+     * then we can convert "context" to an ordinary property getter.
+     * https://github.com/Microsoft/TypeScript/issues/338
+     */
+    protected context?: BaseComponentContext;
+    /**
+     * Stores whether or not this component has a dynamic data source.
+     * @internal
+     */
+    protected _isWebPartAndContainsDynamicDataSource: boolean;
+    private _isDisposed;
+    /**
+     * Returns the dynamic data source id for the current instance of the component.
+     *
+     * @internal
+     */
+    get _dynamicDataSourceId(): string;
+    /** @internal */
+    constructor();
+    /**
+     * Disposes the component.
+     *
+     * @remarks
+     * Third-party code generally does not need to call this method; it's invoked
+     * automatically when the lifecycle ends for a web part or extension.  To perform
+     * custom cleanup when your component is disposed, override the {@link BaseComponent.onDispose}
+     * method.
+     */
+    dispose(): void;
+    /**
+     * Returns whether or not this component contains a dynamic data source.
+     * @internal
+     */
+    get _containsDynamicDataSource(): boolean;
+    /**
+     * @internal
+     */
+    set _containsDynamicDataSource(val: boolean);
+    /**
+     * Returns true if the component has been already disposed.
+     */
+    get isDisposed(): boolean;
+    /**
+     * Provides access to the manifest for the client-side component.
+     * virtual
+     * @remarks
+     * Child classes can override this with more specialized manifest types.
+     */
+    get manifest(): IClientSideComponentManifest;
+    /**
+     * This event method is called at the end of the component's lifecycle.
+     * It provides an opportunity to release any associated resources, cancel any
+     * outstanding requests, etc.
+     * virtual
+     */
+    protected onDispose(): void;
+    /**
+     * A unique identifier for the instance of the component.
+     *
+     * @remarks
+     * A component implementation can be loaded multiple times on the page.
+     * For example, if the component is a charting web part, multiple instances of this web part
+     * could be added to the SharePoint canvas.  The instanceId uniquely identifies each
+     * of these instances.
+     */
+    get instanceId(): string;
+    /**
+     * Returns the component identifier as defined in the component's associated manifest.
+     *
+     * @remarks
+     * Each client-side component has an associated manifest that is used by the sp-loader to load its scripts,
+     * and which may include additional metadata about the component.  The manifest is uniquely identified using
+     * a text string containing a lower case GUID value.
+     */
+    get componentId(): string;
+    /**
+     * @internal
+     */
+    protected _initializeContext(context: BaseComponentContext): void;
+    /**
+     * This event method allows a component to add custom services to its
+     * {@link @microsoft/sp-core-library#ServiceScope}.
+     *
+     * @remarks
+     * This event method is fired before {@link @microsoft/sp-core-library#ServiceScope | ServiceScope.finish()}
+     * is called, allowing the component to provide custom services.
+     *
+     * virtual
+     *
+     * @alpha
+     */
+    protected onProvideServices(serviceScope: ServiceScope): void;
+}
+//# sourceMappingURL=BaseComponent.d.ts.map

package/lib/BaseComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseComponent.d.ts","sourceRoot":"","sources":["../src/BaseComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AAEpF,OAAO,KAAK,oBAAoB,MAAM,wBAAwB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,aAAc,YAAW,gBAAgB;IACrE;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAEzC;;;OAGG;IACH,SAAS,CAAC,sCAAsC,EAAE,OAAO,CAAS;IAElE,OAAO,CAAC,WAAW,CAAkB;IAErC;;;;OAIG;IACH,IAAW,oBAAoB,IAAI,MAAM,CAExC;IAED,gBAAgB;;IAKhB;;;;;;;;OAQG;IACI,OAAO,IAAI,IAAI;IAWtB;;;OAGG;IACH,IAAW,0BAA0B,IAAI,OAAO,CAE/C;IAED;;OAEG;IACH,IAAW,0BAA0B,CAAC,GAAG,EAAE,OAAO,EAEjD;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,OAAO,CAE/B;IAED;;;;;OAKG;IACH,IAAW,QAAQ,IAAI,4BAA4B,CAElD;IAED;;;;;OAKG;IACH,SAAS,CAAC,SAAS,IAAI,IAAI;IAI3B;;;;;;;;OAQG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;;;OAOG;IACH,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;OAEG;IACH,SAAS,CAAC,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAiBjE;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,iBAAiB,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;CAG9D"}

package/lib/BaseComponent.js

@@ -0,0 +1,162 @@
+/**
+ * The base class for client-side components such as BaseClientSideWebPart or BaseExtension.
+ *
+ * @public
+ */
+var BaseComponent = /** @class */ (function () {
+    /** @internal */
+    function BaseComponent() {
+        /**
+         * Stores whether or not this component has a dynamic data source.
+         * @internal
+         */
+        this._isWebPartAndContainsDynamicDataSource = false;
+        this._isDisposed = false;
+        // empty block
+    }
+    Object.defineProperty(BaseComponent.prototype, "_dynamicDataSourceId", {
+        /**
+         * Returns the dynamic data source id for the current instance of the component.
+         *
+         * @internal
+         */
+        get: function () {
+            return "".concat(this.manifest.componentType, ".").concat(this.manifest.id, ".").concat(this.instanceId);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Disposes the component.
+     *
+     * @remarks
+     * Third-party code generally does not need to call this method; it's invoked
+     * automatically when the lifecycle ends for a web part or extension.  To perform
+     * custom cleanup when your component is disposed, override the {@link BaseComponent.onDispose}
+     * method.
+     */
+    BaseComponent.prototype.dispose = function () {
+        if (!this._isDisposed) {
+            this.onDispose();
+            this.context.dispose();
+            delete this.context;
+            this._isDisposed = true;
+        }
+    };
+    Object.defineProperty(BaseComponent.prototype, "_containsDynamicDataSource", {
+        /**
+         * Returns whether or not this component contains a dynamic data source.
+         * @internal
+         */
+        get: function () {
+            return this._isWebPartAndContainsDynamicDataSource;
+        },
+        /**
+         * @internal
+         */
+        set: function (val) {
+            this._isWebPartAndContainsDynamicDataSource = this.manifest.componentType === 'WebPart' ? val : false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponent.prototype, "isDisposed", {
+        /**
+         * Returns true if the component has been already disposed.
+         */
+        get: function () {
+            return this._isDisposed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponent.prototype, "manifest", {
+        /**
+         * Provides access to the manifest for the client-side component.
+         * virtual
+         * @remarks
+         * Child classes can override this with more specialized manifest types.
+         */
+        get: function () {
+            return this.context.manifest;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * This event method is called at the end of the component's lifecycle.
+     * It provides an opportunity to release any associated resources, cancel any
+     * outstanding requests, etc.
+     * virtual
+     */
+    BaseComponent.prototype.onDispose = function () {
+        // (empty block)
+    };
+    Object.defineProperty(BaseComponent.prototype, "instanceId", {
+        /**
+         * A unique identifier for the instance of the component.
+         *
+         * @remarks
+         * A component implementation can be loaded multiple times on the page.
+         * For example, if the component is a charting web part, multiple instances of this web part
+         * could be added to the SharePoint canvas.  The instanceId uniquely identifies each
+         * of these instances.
+         */
+        get: function () {
+            return this.context.instanceId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponent.prototype, "componentId", {
+        /**
+         * Returns the component identifier as defined in the component's associated manifest.
+         *
+         * @remarks
+         * Each client-side component has an associated manifest that is used by the sp-loader to load its scripts,
+         * and which may include additional metadata about the component.  The manifest is uniquely identified using
+         * a text string containing a lower case GUID value.
+         */
+        get: function () {
+            return this.context.manifest.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @internal
+     */
+    BaseComponent.prototype._initializeContext = function (context) {
+        this.context = context;
+        this.onProvideServices(context.serviceScope);
+        /*
+         * Calling finish on an already finished servicescope will throw.
+         * Hence, checking it before finishing the servicescope.
+         *
+         * In the case of ApplicationCustomizers, it's context is calling 'finish'
+         * on the service scope. Hence, it is required to have the below check.
+         */
+        if (!context.serviceScope._isFinished) {
+            context.serviceScope.finish();
+        }
+        this.context._initializeDynamicData(this, context.serviceScope);
+    };
+    /**
+     * This event method allows a component to add custom services to its
+     * {@link @microsoft/sp-core-library#ServiceScope}.
+     *
+     * @remarks
+     * This event method is fired before {@link @microsoft/sp-core-library#ServiceScope | ServiceScope.finish()}
+     * is called, allowing the component to provide custom services.
+     *
+     * virtual
+     *
+     * @alpha
+     */
+    BaseComponent.prototype.onProvideServices = function (serviceScope) {
+        // empty block
+    };
+    return BaseComponent;
+}());
+export default BaseComponent;
+//# sourceMappingURL=BaseComponent.js.map

package/lib/BaseComponentContext.d.ts

@@ -0,0 +1,142 @@
+import { type ServiceScope, type IDisposable } from '@microsoft/sp-core-library';
+import type { IClientSideComponentManifest } from '@microsoft/sp-module-interfaces';
+import { PageContext } from '@microsoft/sp-page-context';
+import { HttpClient, SPHttpClient, AadHttpClientFactory, AadTokenProviderFactory, MSGraphClientFactory } from '@microsoft/sp-http';
+import type BaseComponent from './BaseComponent';
+import DynamicDataProvider from './DynamicDataProvider';
+import DynamicDataSourceManager from './DynamicDataSourceManager';
+/**
+ * Constructor parameters for a BaseComponentContext.
+ *
+ * @internal
+ */
+export interface IComponentContextParameters {
+    /**
+     * The manager's ServiceScope, which will be used to create the child
+     * ServiceScope for the associated context.
+     */
+    readonly parentServiceScope: ServiceScope;
+    /**
+     * The client-side component manifest.
+     */
+    readonly manifest: IClientSideComponentManifest;
+    /**
+     * Logging service tag
+     */
+    readonly loggingTag: string;
+    /**
+     * Instance id for the client-side component.
+     */
+    readonly instanceId: string;
+}
+/**
+ * The base class for context objects for client-side components.
+ *
+ * @remarks
+ * A "context" object is a collection of well-known services and other
+ * objects that are likely to be needed by business logic that interacts with a
+ * associated component.  Each component type has its own specialized subclass
+ * of BaseComponentContext, e.g. WebPartContext for web parts, ExtensionContext for
+ * client-side extensions, and so on.
+ *
+ * @privateRemarks
+ *
+ * NOTE: The context object is a convenience that avoids the overhead of
+ * properly factoring the dependencies for every class in a project.
+ * If lots of members are added to the context without discipline, it can
+ * easily devolve into a poor engineering practice (where "everything depends
+ * on everything else").  Think carefully before adding more objects to the context object.
+ * Is it really a core scenario?  Is it unnecessarily coupling your package to another
+ * package?  Is there a better place to put the object?
+ *
+ * Only add data properties or well-defined classes with ubiquitous applicability.
+ * Never add loose functions, callbacks, or settable properties to the context.
+ *
+ * @public
+ */
+declare abstract class BaseComponentContext implements IDisposable {
+    /**
+     * Manifest for the client-side component.
+     */
+    readonly manifest: IClientSideComponentManifest;
+    private _serviceScope;
+    private _instanceId;
+    private _pageContext;
+    private _dynamicDataProvider;
+    private _dynamicDataSourceManager;
+    private _isDisposed;
+    private _httpClient;
+    private _spHttpClient;
+    private _aadClientFactory;
+    private _aadTokenFactory;
+    private _msGraphClientFactory;
+    private _isServedFromLocalhost;
+    /** @internal */
+    constructor(parameters: IComponentContextParameters);
+    /**
+     * Returns true if the context is disposed.
+     */
+    get isDisposed(): boolean;
+    /**
+     * Disposes the base component context.
+     */
+    dispose(): void;
+    /**
+     * The associated {@link @microsoft/sp-core-library#ServiceScope} for this component.
+     * @remarks
+     * A child service scope is created for each client-side component.
+     */
+    get serviceScope(): ServiceScope;
+    /**
+     * {@inheritDoc BaseComponent.instanceId}
+     */
+    get instanceId(): string;
+    /**
+     * The page context provides standard definitions for common SharePoint objects
+     * that need to be shared between the client-side application, web parts, and other
+     * components.
+     */
+    get pageContext(): PageContext;
+    /**
+     * Creates a Dynamic Data Provider for the component.
+     *
+     * @param component - Component tied to the Dynamic Data Provider
+     * @param serviceScope - ServiceScope to consume the Dynamic Data Manager from. Must be finished.
+     * @internal
+     */
+    _initializeDynamicData(component: BaseComponent, serviceScope: ServiceScope): void;
+    /**
+     * Returns the Dynamic Data Provider associated with the component.
+     */
+    get dynamicDataProvider(): DynamicDataProvider;
+    /**
+     * Returns the Dynamic Data Source Manager associated with the component.
+     */
+    get dynamicDataSourceManager(): DynamicDataSourceManager;
+    /**
+     * The instance of AadHttpClientFactory created for this instance of component
+     */
+    get aadHttpClientFactory(): AadHttpClientFactory;
+    /**
+     * The instance of AadTokenProviderFactory created for this instance of component
+     */
+    get aadTokenProviderFactory(): AadTokenProviderFactory;
+    /**
+     * The instance of MSGraphClientFactory created for this instance of component
+     */
+    get msGraphClientFactory(): MSGraphClientFactory;
+    /**
+     * The instance of HttpClient created for this instance of component
+     */
+    get httpClient(): HttpClient;
+    /**
+     * The instance of SpHttpClient created for this instance of component
+     */
+    get spHttpClient(): SPHttpClient;
+    /**
+     * Returns true if the solution is being served from localhost
+     */
+    get isServedFromLocalhost(): boolean;
+}
+export default BaseComponentContext;
+//# sourceMappingURL=BaseComponentContext.d.ts.map

package/lib/BaseComponentContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseComponentContext.d.ts","sourceRoot":"","sources":["../src/BaseComponentContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,WAAW,EAEjB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EACL,UAAU,EACV,YAAY,EACZ,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,aAAa,MAAM,iBAAiB,CAAC;AACjD,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAElE;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,EAAE,YAAY,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,4BAA4B,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,uBAAe,oBAAqB,YAAW,WAAW;IACxD;;OAEG;IACH,SAAgB,QAAQ,EAAE,4BAA4B,CAAC;IAEvD,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,yBAAyB,CAAuC;IACxE,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,iBAAiB,CAAuB;IAChD,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,qBAAqB,CAAuB;IACpD,OAAO,CAAC,sBAAsB,CAAkB;IAEhD,gBAAgB;gBACG,UAAU,EAAE,2BAA2B;IA0C1D;;OAEG;IACH,IAAW,UAAU,IAAI,OAAO,CAE/B;IAED;;OAEG;IACI,OAAO,IAAI,IAAI;IAkBtB;;;;OAIG;IACH,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;OAIG;IACH,IAAW,WAAW,IAAI,WAAW,CAEpC;IAED;;;;;;OAMG;IACI,sBAAsB,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI;IAKzF;;OAEG;IACH,IAAW,mBAAmB,IAAI,mBAAmB,CAEpD;IAED;;OAEG;IACH,IAAW,wBAAwB,IAAI,wBAAwB,CAE9D;IAED;;OAEG;IACH,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAED;;OAEG;IACH,IAAW,uBAAuB,IAAI,uBAAuB,CAE5D;IAED;;OAEG;IACH,IAAW,oBAAoB,IAAI,oBAAoB,CAEtD;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,UAAU,CAElC;IAED;;OAEG;IACH,IAAW,YAAY,IAAI,YAAY,CAEtC;IAED;;OAEG;IACH,IAAW,qBAAqB,IAAI,OAAO,CAE1C;CACF;AAED,eAAe,oBAAoB,CAAC"}

package/lib/BaseComponentContext.js

@@ -0,0 +1,221 @@
+import { Validate, _ClientManifestData } from '@microsoft/sp-core-library';
+import { _LogSource, _logSourceServiceKey } from '@microsoft/sp-diagnostics';
+import { PageContext } from '@microsoft/sp-page-context';
+import { HttpClient, SPHttpClient, AadHttpClientFactory, AadTokenProviderFactory, MSGraphClientFactory } from '@microsoft/sp-http';
+import DynamicDataProvider from './DynamicDataProvider';
+import DynamicDataSourceManager from './DynamicDataSourceManager';
+/**
+ * The base class for context objects for client-side components.
+ *
+ * @remarks
+ * A "context" object is a collection of well-known services and other
+ * objects that are likely to be needed by business logic that interacts with a
+ * associated component.  Each component type has its own specialized subclass
+ * of BaseComponentContext, e.g. WebPartContext for web parts, ExtensionContext for
+ * client-side extensions, and so on.
+ *
+ * @privateRemarks
+ *
+ * NOTE: The context object is a convenience that avoids the overhead of
+ * properly factoring the dependencies for every class in a project.
+ * If lots of members are added to the context without discipline, it can
+ * easily devolve into a poor engineering practice (where "everything depends
+ * on everything else").  Think carefully before adding more objects to the context object.
+ * Is it really a core scenario?  Is it unnecessarily coupling your package to another
+ * package?  Is there a better place to put the object?
+ *
+ * Only add data properties or well-defined classes with ubiquitous applicability.
+ * Never add loose functions, callbacks, or settable properties to the context.
+ *
+ * @public
+ */
+var BaseComponentContext = /** @class */ (function () {
+    /** @internal */
+    function BaseComponentContext(parameters) {
+        var _this = this;
+        this._isDisposed = false;
+        this._isServedFromLocalhost = false;
+        Validate.isNotNullOrUndefined(parameters, 'parameters');
+        Validate.isNotNullOrUndefined(parameters.manifest, 'manifest');
+        this.manifest = parameters.manifest;
+        var loaderConfig = this.manifest.loaderConfig;
+        if (loaderConfig && loaderConfig.internalModuleBaseUrls && loaderConfig.internalModuleBaseUrls.length) {
+            this._isServedFromLocalhost = /^http(s)?\:\/\/(localhost|127.0.0.1)/gim.test(loaderConfig.internalModuleBaseUrls[0]);
+        }
+        Validate.isNotNullOrUndefined(parameters.parentServiceScope, 'parentServiceScope');
+        this._serviceScope = parameters.parentServiceScope.startNewChild();
+        // TODO: VSO:507790 Reconcile this with ClientSideWebPartManager._createWebPartTag()
+        Validate.isNotNullOrUndefined(parameters.loggingTag, 'loggingTag');
+        this.serviceScope.provide(_logSourceServiceKey, _LogSource.create(parameters.loggingTag));
+        Validate.isNonemptyString(parameters.instanceId, 'instanceId');
+        this._instanceId = parameters.instanceId;
+        this._httpClient = this.serviceScope.createDefaultAndProvide(HttpClient.serviceKey);
+        this._spHttpClient = this.serviceScope.createDefaultAndProvide(SPHttpClient.serviceKey);
+        this._msGraphClientFactory = this.serviceScope.createDefaultAndProvide(MSGraphClientFactory.serviceKey);
+        this._aadClientFactory = this.serviceScope.createDefaultAndProvide(AadHttpClientFactory.serviceKey);
+        this._aadTokenFactory = this.serviceScope.createDefaultAndProvide(AadTokenProviderFactory.serviceKey);
+        this.serviceScope.provide(_ClientManifestData.serviceKey, new _ClientManifestData(this.serviceScope, this.manifest));
+        // Consume services
+        this.serviceScope.whenFinished(function () {
+            _this._pageContext = _this.serviceScope.consume(PageContext.serviceKey);
+        });
+        this._dynamicDataProvider = new DynamicDataProvider();
+        this._dynamicDataSourceManager = new DynamicDataSourceManager();
+    }
+    Object.defineProperty(BaseComponentContext.prototype, "isDisposed", {
+        /**
+         * Returns true if the context is disposed.
+         */
+        get: function () {
+            return this._isDisposed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Disposes the base component context.
+     */
+    BaseComponentContext.prototype.dispose = function () {
+        if (!this._isDisposed) {
+            if (this._dynamicDataProvider) {
+                this._dynamicDataProvider.dispose();
+            }
+            if (this._dynamicDataSourceManager) {
+                this._dynamicDataSourceManager.dispose();
+            }
+            delete this._serviceScope;
+            delete this._pageContext;
+            delete this._dynamicDataProvider;
+            delete this._dynamicDataSourceManager;
+            this._isDisposed = true;
+        }
+    };
+    Object.defineProperty(BaseComponentContext.prototype, "serviceScope", {
+        /**
+         * The associated {@link @microsoft/sp-core-library#ServiceScope} for this component.
+         * @remarks
+         * A child service scope is created for each client-side component.
+         */
+        get: function () {
+            return this._serviceScope;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "instanceId", {
+        /**
+         * {@inheritDoc BaseComponent.instanceId}
+         */
+        get: function () {
+            return this._instanceId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "pageContext", {
+        /**
+         * The page context provides standard definitions for common SharePoint objects
+         * that need to be shared between the client-side application, web parts, and other
+         * components.
+         */
+        get: function () {
+            return this._pageContext;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Creates a Dynamic Data Provider for the component.
+     *
+     * @param component - Component tied to the Dynamic Data Provider
+     * @param serviceScope - ServiceScope to consume the Dynamic Data Manager from. Must be finished.
+     * @internal
+     */
+    BaseComponentContext.prototype._initializeDynamicData = function (component, serviceScope) {
+        this._dynamicDataProvider._initialize(component, serviceScope);
+        this._dynamicDataSourceManager._initialize(component, serviceScope);
+    };
+    Object.defineProperty(BaseComponentContext.prototype, "dynamicDataProvider", {
+        /**
+         * Returns the Dynamic Data Provider associated with the component.
+         */
+        get: function () {
+            return this._dynamicDataProvider;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "dynamicDataSourceManager", {
+        /**
+         * Returns the Dynamic Data Source Manager associated with the component.
+         */
+        get: function () {
+            return this._dynamicDataSourceManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "aadHttpClientFactory", {
+        /**
+         * The instance of AadHttpClientFactory created for this instance of component
+         */
+        get: function () {
+            return this._aadClientFactory;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "aadTokenProviderFactory", {
+        /**
+         * The instance of AadTokenProviderFactory created for this instance of component
+         */
+        get: function () {
+            return this._aadTokenFactory;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "msGraphClientFactory", {
+        /**
+         * The instance of MSGraphClientFactory created for this instance of component
+         */
+        get: function () {
+            return this._msGraphClientFactory;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "httpClient", {
+        /**
+         * The instance of HttpClient created for this instance of component
+         */
+        get: function () {
+            return this._httpClient;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "spHttpClient", {
+        /**
+         * The instance of SpHttpClient created for this instance of component
+         */
+        get: function () {
+            return this._spHttpClient;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseComponentContext.prototype, "isServedFromLocalhost", {
+        /**
+         * Returns true if the solution is being served from localhost
+         */
+        get: function () {
+            return this._isServedFromLocalhost;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BaseComponentContext;
+}());
+export default BaseComponentContext;
+//# sourceMappingURL=BaseComponentContext.js.map