@microsoft/sp-component-base 1.23.1 → 1.24.0-beta.2

package/lib-esm/BaseComponent.js

@@ -0,0 +1,123 @@
+import { _ES5CompatibleClass } from '@microsoft/sp-core-library';
+class BaseComponent {
+    /**
+   * Returns the dynamic data source id for the current instance of the component.
+   *
+   * @internal
+   */ get _dynamicDataSourceId() {
+        return `${this.manifest.componentType}.${this.manifest.id}.${this.instanceId}`;
+    }
+    /**
+   * 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() {
+        if (!this._isDisposed) {
+            this.onDispose();
+            this.context.dispose();
+            delete this.context;
+            this._isDisposed = true;
+        }
+    }
+    /**
+   * Returns whether or not this component contains a dynamic data source.
+   * @internal
+   */ get _containsDynamicDataSource() {
+        return this._isWebPartAndContainsDynamicDataSource;
+    }
+    set _containsDynamicDataSource(val) {
+        this._isWebPartAndContainsDynamicDataSource = this.manifest.componentType === 'WebPart' ? val : false;
+    }
+    /**
+   * Returns true if the component has been already disposed.
+   */ get isDisposed() {
+        return this._isDisposed;
+    }
+    /**
+   * Provides access to the manifest for the client-side component.
+   *
+   * @remarks
+   * The manifest type is determined by the `TClientSideComponentManifest` generic parameter.
+   */ get manifest() {
+        return this.context.manifest;
+    }
+    /**
+   * 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
+   */ onDispose() {
+    // (empty block)
+    }
+    /**
+   * 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() {
+        return this.context.instanceId;
+    }
+    /**
+   * 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() {
+        return this.context.manifest.id;
+    }
+    /**
+   * @internal
+   */ _initializeContext(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
+   */ onProvideServices(serviceScope) {
+    // empty block
+    }
+    /** @internal */ constructor(){
+        /**
+   * Stores whether or not this component has a dynamic data source.
+   * @internal
+   */ this._isWebPartAndContainsDynamicDataSource = false;
+        this._isDisposed = false;
+    // empty block
+    }
+}
+/**
+ * The base class for client-side components such as BaseClientSideWebPart or BaseExtension.
+ *
+ * @public
+ */ export { BaseComponent as default };
+_ES5CompatibleClass(BaseComponent);
+
+//# sourceMappingURL=./BaseComponent.js.map

package/lib-esm/BaseComponentContext.js

@@ -0,0 +1,157 @@
+import { Validate, _ClientManifestData, _ES5CompatibleClass } 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
+ */ class BaseComponentContext {
+    /**
+   * Returns true if the context is disposed.
+   */ get isDisposed() {
+        return this._isDisposed;
+    }
+    /**
+   * Disposes the base component context.
+   */ dispose() {
+        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;
+        }
+    }
+    /**
+   * 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() {
+        return this._serviceScope;
+    }
+    /**
+   * {@inheritDoc BaseComponent.instanceId}
+   */ get instanceId() {
+        return this._instanceId;
+    }
+    /**
+   * 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() {
+        return this._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, serviceScope) {
+        this._dynamicDataProvider._initialize(component, serviceScope);
+        this._dynamicDataSourceManager._initialize(component, serviceScope);
+    }
+    /**
+   * Returns the Dynamic Data Provider associated with the component.
+   */ get dynamicDataProvider() {
+        return this._dynamicDataProvider;
+    }
+    /**
+   * Returns the Dynamic Data Source Manager associated with the component.
+   */ get dynamicDataSourceManager() {
+        return this._dynamicDataSourceManager;
+    }
+    /**
+   * The instance of AadHttpClientFactory created for this instance of component
+   */ get aadHttpClientFactory() {
+        return this._aadClientFactory;
+    }
+    /**
+   * The instance of AadTokenProviderFactory created for this instance of component
+   */ get aadTokenProviderFactory() {
+        return this._aadTokenFactory;
+    }
+    /**
+   * The instance of MSGraphClientFactory created for this instance of component
+   */ get msGraphClientFactory() {
+        return this._msGraphClientFactory;
+    }
+    /**
+   * The instance of HttpClient created for this instance of component
+   */ get httpClient() {
+        return this._httpClient;
+    }
+    /**
+   * The instance of SpHttpClient created for this instance of component
+   */ get spHttpClient() {
+        return this._spHttpClient;
+    }
+    /**
+   * Returns true if the solution is being served from localhost
+   */ get isServedFromLocalhost() {
+        return this._isServedFromLocalhost;
+    }
+    /** @internal */ constructor(parameters){
+        this._isDisposed = false;
+        this._isServedFromLocalhost = false;
+        Validate.isNotNullOrUndefined(parameters, 'parameters');
+        Validate.isNotNullOrUndefined(parameters.manifest, 'manifest');
+        this.manifest = parameters.manifest;
+        const { loaderConfig } = this.manifest;
+        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(()=>{
+            this._pageContext = this.serviceScope.consume(PageContext.serviceKey);
+        });
+        this._dynamicDataProvider = new DynamicDataProvider();
+        this._dynamicDataSourceManager = new DynamicDataSourceManager();
+    }
+}
+_ES5CompatibleClass(BaseComponentContext);
+export default BaseComponentContext;
+
+//# sourceMappingURL=./BaseComponentContext.js.map

package/lib-esm/DynamicDataProvider.js

@@ -0,0 +1,401 @@
+import { Validate, Guid } from '@microsoft/sp-core-library';
+import { _EngagementLogger, _LogEntry, _LogType } from '@microsoft/sp-diagnostics';
+import { _DynamicDataUtilities } from '@microsoft/sp-dynamic-data';
+import * as lodash from '@microsoft/sp-lodash-subset';
+class DynamicDataProvider {
+    /**
+   * Initializes the Dynamic Data Provider for a specific component.
+   *
+   * @param component - Component that is going to use the Dynamic Data Provider.
+   *
+   * @internal
+   */ _initialize(component, serviceScope) {
+        Validate.isNotNullOrUndefined(component, 'component');
+        Validate.isNotNullOrUndefined(serviceScope, 'serviceScope');
+        this._component = component;
+        // Initialize all the required datastructures
+        this._pendingRegistrations = new Map();
+        this._dynamicDataManager = serviceScope.consume(_DynamicDataUtilities.IDynamicDataManagerServiceKey);
+        this._isInitialized = true;
+        // Method bindings
+        this._onSourcesChanged = this._onSourcesChanged.bind(this);
+    }
+    /**
+   * Disposes the Dynamic Data Provider.
+   */ dispose() {
+        if (!this._isDisposed) {
+            delete this._pendingRegistrations;
+            this._dynamicDataManager.sourcesChangedEvent.remove(this._component, this._onSourcesChanged);
+            delete this._dynamicDataManager;
+            delete this._component;
+            this._isInitialized = false;
+            this._isDisposed = true;
+        }
+    }
+    /**
+   * Returns true if the Dynamic Data Provider is disposed.
+   */ get isDisposed() {
+        return this._isDisposed;
+    }
+    /**
+   * Returns true if the Dynamic Data Provider is intialized.
+   * @internal
+   */ get _isProviderInitialized() {
+        return this._isInitialized;
+    }
+    /**
+   * Returns the dynamic data source id for the current instance of the component.
+   * @internal
+   */ get _dynamicDataSourceId() {
+        return this._component._dynamicDataSourceId;
+    }
+    /**
+   * Registers a callback for updates when a Dynamic Data source is changed.
+   * This happens when any property is updated within the source.
+   *
+   * @privateRemarks
+   * We register the source, only if the source is available else defer the registration
+   * to when the availableSources change.
+   *
+   * @param sourceId - Id of the Dynamic Data Source.
+   * @param callback - Function to execute when the source updates its data.
+   */ registerSourceChanged(sourceId, callback) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        Validate.isNonemptyString(sourceId, 'sourceId');
+        Validate.isNotNullOrUndefined(callback, 'callback');
+        const availableSourceIds = this.getAvailableSources().map((source)=>source.id);
+        if (availableSourceIds.indexOf(sourceId) !== -1) {
+            // requested source is available
+            this._dynamicDataManager.registerSourceChanged(sourceId, this._component, callback);
+            this._logFeatureEntry('RegisterSourceChanged', {
+                sourceId: sourceId
+            });
+        } else {
+            // requested source is NOT available
+            this._addPendingRegistration({
+                id: sourceId,
+                callback: callback
+            });
+        }
+    }
+    /**
+   * Unregisters a callback for updates when a Dynamic Data source is changed.
+   *
+   * @param sourceId - Id of the Dynamic Data Source.
+   * @param callback - Function to remove from the registration. Must be the same it was registered with.
+   */ unregisterSourceChanged(sourceId, callback) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        Validate.isNonemptyString(sourceId, 'sourceId');
+        Validate.isNotNullOrUndefined(callback, 'callback');
+        const registration = {
+            id: sourceId,
+            callback: callback
+        };
+        if (!this._isRegistrationPending(registration)) {
+            // Source is already registered.
+            this._dynamicDataManager.unregisterSourceChanged(sourceId, this._component, callback);
+            this._logFeatureEntry('UnregisterSourceChanged', {
+                sourceId: sourceId
+            });
+        } else {
+            // Source is in pending state
+            this._removePendingRegistration(registration);
+        }
+    }
+    /**
+   * Registers a callback for updates when a property is changed in a Dynamic Data source.
+   *
+   * @privateRemarks
+   * We register the source, only if the source is available else defer the registration
+   * to when the availableSources change.
+   *
+   * @param sourceId - Id of the Dynamic Data Source.
+   * @param propertyId - Id of the property of the source.
+   * @param callback - Function to execute when the source updates its data.
+   */ registerPropertyChanged(sourceId, propertyId, callback) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        Validate.isNonemptyString(sourceId, 'sourceId');
+        Validate.isNonemptyString(propertyId, 'propertyId');
+        Validate.isNotNullOrUndefined(callback, 'callback');
+        const availableSourceIds = this.getAvailableSources().map((source)=>source.id);
+        if (availableSourceIds.indexOf(sourceId) !== -1) {
+            // requested source is available
+            this._dynamicDataManager.registerPropertyChanged(sourceId, propertyId, this._component, callback);
+            this._logFeatureEntry('RegisterPropertyChanged', {
+                sourceId: sourceId,
+                propertyId: propertyId
+            });
+        } else {
+            // requested source is NOT available
+            this._addPendingRegistration({
+                id: sourceId,
+                propertyId: propertyId,
+                callback: callback
+            });
+        }
+    }
+    /**
+   * Unregisters a callback for updates when a property is changed in a Dynamic Data source.
+   *
+   * @privateRemarks
+   * If the sourceId is present in _registeredSourcesForPropertyChanged then
+   *    it removes from sourceID from the set _registeredSourcesForPropertyChanged and
+   *    invokes unregisterPropertyChanged event on the DynamicDataManager
+   *
+   * else if the sourceId is present in _pendingSourcesForPropertyChanged then
+   *    it just removes the sourceId from the set _pendingSourcesForPropertyChanged
+   *
+   * @param sourceId - Id of the Dynamic Data Source.
+   * @param propertyId - Id of the property of the source.
+   * @param callback - Function to remove from the registration. Must be the same it was registered with.
+   */ unregisterPropertyChanged(sourceId, propertyId, callback) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        Validate.isNonemptyString(sourceId, 'sourceId');
+        Validate.isNonemptyString(propertyId, 'propertyId');
+        Validate.isNotNullOrUndefined(callback, 'callback');
+        const registration = {
+            id: sourceId,
+            callback: callback,
+            propertyId: propertyId
+        };
+        // registration is in pending state.
+        if (!this._isRegistrationPending(registration)) {
+            this._dynamicDataManager.unregisterPropertyChanged(sourceId, propertyId, this._component, callback);
+            this._logFeatureEntry('UnregisterPropertyChanged', {
+                sourceId: sourceId,
+                propertyId: propertyId
+            });
+        } else {
+            // Already registered.
+            this._removePendingRegistration(registration);
+        }
+    }
+    /**
+   * Registers a callback to an event that raises when the list of available Dynamic Data Sources is updated.
+   *
+   * @param callback - Function to execute when the sources are updated.
+   */ registerAvailableSourcesChanged(callback) {
+        Validate.isNotNullOrUndefined(callback, 'callback');
+        this._assertNotDisposed();
+        this._assertInitialized();
+        this._dynamicDataManager.sourcesChangedEvent.add(this._component, callback);
+    }
+    /**
+   * Unregisters a callback to an event that raises when the list of available Dynamic Data Sources is updated.
+   *
+   * @privateRemarks
+   * This api is used by the consumer of the dynamic data.
+   *
+   * @param callback - Function to remove from the registration. Must be the same it was registered with.
+   */ unregisterAvailableSourcesChanged(callback) {
+        Validate.isNotNullOrUndefined(callback, 'callback');
+        this._assertNotDisposed();
+        this._assertInitialized();
+        this._dynamicDataManager.sourcesChangedEvent.remove(this._component, callback);
+    }
+    /**
+   * Returns a list with all available Dynamic Data Sources.
+   *
+   * @returns Read-only array with all available sources.
+   */ getAvailableSources() {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        return this._dynamicDataManager.getSources();
+    }
+    /**
+   * Returns a list of all the available Dynamic Data Sources which have same component id.
+   *
+   * @returns Read-only array of available sources with same component id.
+   * @alpha
+   */ getAvailableSourcesByComponentId(componentId) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        const sources = [];
+        this._dynamicDataManager.getSources().forEach((source)=>{
+            if (componentId.equals(Guid.tryParse(source.metadata.componentId) || Guid.empty)) {
+                sources.push(source);
+            }
+        });
+        return sources;
+    }
+    /**
+   * Returns a Dynamic Data Source, by its id.
+   * If the source is not present, it returns undefined.
+   *
+   * @param id - Id of the Dynamic Data Source.
+   */ tryGetSource(id) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        Validate.isNotNullOrUndefined(id, 'id');
+        return this._dynamicDataManager.tryGetSource(id);
+    }
+    /**
+   * Returns specific data from a source based on a Dynamic Data reference.
+   *
+   * @param dataReference - Dynamic Data Reference.
+   * @internal
+   */ _getData(dataReference) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        Validate.isNotNullOrUndefined(dataReference, 'dataReference');
+        const dataSource = this._dynamicDataManager.tryGetSource(dataReference.sourceId);
+        if (!dataSource) {
+            return undefined;
+        }
+        let data = dataSource.getPropertyValue(dataReference.property);
+        if (data && dataReference.propertyPath) {
+            // multiple levels of sub-properties are separated by '.' in the property path.
+            const subpaths = dataReference.propertyPath.split('.');
+            subpaths.forEach((subpath)=>{
+                // If sub-property yields to an array value, then the path to the sub-property
+                // will have [*] appended after the name of the sub-property.
+                // Hence separating out to get the subPropertyName.
+                const subpathElements = subpath.split(DynamicDataProvider._jsonPathArrayRegex);
+                const subProperty = subpathElements[0];
+                // If the supplied reference has an array([*]) notation, then we extract the data
+                // accordingly. [*] means all the entries and if there is a number instead of the '*'
+                // then extract that specific entry.
+                if (data) {
+                    if (Array.isArray(data)) {
+                        let dataItems = [];
+                        data.forEach((item)=>{
+                            if (item.hasOwnProperty(subProperty)) {
+                                dataItems.push(item[subProperty]);
+                            }
+                        });
+                        /*
+             * If a specific entry is asked, we return it else we return all the entries,
+             * essentially it is treated as [*].
+             */ const index = subpathElements[1];
+                        if (subpathElements.length > 1) {
+                            /**
+               * This means that the current subpath element is an array type, an array inside an array.
+               * Since the subpath element is an array, we are normalizing the existing dataItems object
+               * i.e., dataItems will have an array of array objects.
+               */ const tempDataItems = [];
+                            dataItems.forEach((dataItem)=>{
+                                dataItem.forEach((internalItem)=>tempDataItems.push(internalItem));
+                            });
+                            dataItems = tempDataItems;
+                        }
+                        if (!isNaN(parseInt(index, 10))) {
+                            data = dataItems[index];
+                        } else {
+                            data = dataItems;
+                        }
+                    } else if (data.hasOwnProperty(subProperty)) {
+                        // data is an object type
+                        data = data[subProperty];
+                    } else {
+                        // If the control is here, it means that the subProperty was not found in data.
+                        // Hence the next iteration would get data as undefined.
+                        data = undefined;
+                    }
+                }
+            });
+        }
+        return data;
+    }
+    _onSourcesChanged() {
+        const availableSourceIds = this.getAvailableSources().map((source)=>source.id);
+        // Registering to sourceChanged event
+        this._pendingRegistrations.forEach((src)=>{
+            // register to sourceChanged event, if the source is available.
+            if (availableSourceIds.indexOf(src.id) !== -1) {
+                // Source is available
+                if (!src.propertyId) {
+                    // No propertyId, means register to sourceChanged event.
+                    this._dynamicDataManager.registerSourceChanged(src.id, this._component, src.callback);
+                    this._logFeatureEntry('RegisterSourceChanged', {
+                        sourceId: src.id
+                    });
+                } else {
+                    // With propertyId, means register to propertyChanged event.
+                    this._dynamicDataManager.registerPropertyChanged(src.id, src.propertyId, this._component, src.callback);
+                    this._logFeatureEntry('RegisterPropertyChanged', {
+                        sourceId: src.id,
+                        propertyId: src.propertyId
+                    });
+                }
+                this._removePendingRegistration(src);
+            }
+        });
+    }
+    _assertNotDisposed() {
+        if (this.isDisposed) {
+            throw new Error('Dynamic Data Provider has been disposed');
+        }
+    }
+    _assertInitialized() {
+        if (!this._isInitialized) {
+            throw new Error('Dynamic Data Provider has not been initialized.');
+        }
+    }
+    /**
+   * Adds the registration to the pending registrations if not already added.
+   * Also adds a listener to the _DynamicDataManager's sourcesChangedEvent.
+   */ _addPendingRegistration(registration) {
+        if (!this._isRegistrationPending(registration)) {
+            this._pendingRegistrations.set(registration.id + (registration.propertyId || ''), {
+                id: registration.id,
+                propertyId: registration.propertyId,
+                callback: registration.callback
+            });
+        }
+        if (!this._isSourcesChangedEventListenerAdded) {
+            this._dynamicDataManager.sourcesChangedEvent.add(this._component, this._onSourcesChanged);
+            this._isSourcesChangedEventListenerAdded = true;
+        }
+    }
+    /**
+   * Removes the pending registration and then, if there are no more pending registrations
+   * remove the 'sourcesChangedEvent' listener.
+   */ _removePendingRegistration(registration) {
+        this._pendingRegistrations.delete(registration.id + (registration.propertyId || ''));
+        if (this._pendingRegistrations.size === 0) {
+            this._dynamicDataManager.sourcesChangedEvent.remove(this._component, this._onSourcesChanged);
+            this._isSourcesChangedEventListenerAdded = false;
+        }
+    }
+    /**
+   * Returns true if the incoming source is already added to the _pendingRegistrations Map.
+   *
+   * @param incomingRegistration - registration to be checked.
+   */ _isRegistrationPending(incomingRegistration) {
+        return this._pendingRegistrations.has(incomingRegistration.id + (incomingRegistration.propertyId || ''));
+    }
+    /**
+   * Logs a feature event with any extra data from the producer of the event.
+   * @param logFeature - Name of the feature to log.
+   * @param contextualProps - Contextual log properties of the feature event.
+   */ _logFeatureEntry(logFeature, contextualProps) {
+        const isInternal = this._component.manifest.isInternal || false;
+        const logProperties = {
+            alias: this._component.manifest.alias,
+            isInternal: isInternal.toString()
+        };
+        const logEntry = new _LogEntry('DynamicDataProvider', logFeature, _LogType.Event, lodash.merge(logProperties, contextualProps));
+        _EngagementLogger.logEventWithLogEntry(logEntry);
+    }
+    constructor(){
+        this._isDisposed = false;
+        this._isInitialized = false;
+        this._isSourcesChangedEventListenerAdded = false;
+    }
+}
+/**
+   * Regular expression to evaluate arrays in a json path expression.
+   * @internal
+   */ DynamicDataProvider._jsonPathArrayRegex = new RegExp(/\[|\]/);
+/**
+ * The Dynamic Data Provider allows components to consume Dynamic Data.
+ * It allows components to request Dynamic Data sources and register/unregister to those.
+ *
+ * @public
+ */ export { DynamicDataProvider as default };
+
+//# sourceMappingURL=./DynamicDataProvider.js.map