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

package/lib/DynamicDataSourceManager.d.ts

@@ -0,0 +1,160 @@
+import { type IDisposable, type ServiceScope } from '@microsoft/sp-core-library';
+import { type IDynamicDataCallables, type IDynamicDataSource, type IDynamicDataSourceMetadata } from '@microsoft/sp-dynamic-data';
+import type BaseComponent from './BaseComponent';
+/**
+ * The Dynamic Data Source Manager is responsible for:
+ *  - Constructing the dynamic data source
+ *  - Allowing initialization of the dynamic data source by a component
+ *  - Allowing data source to update its metadata and notify when data has been updated.
+ *
+ * @public
+ */
+export default class DynamicDataSourceManager implements IDisposable {
+    private _dynamicDataManager;
+    private _component;
+    private _callableFunctions;
+    private _src;
+    private _isDisposed;
+    private _isInitialized;
+    private _logSource;
+    /**
+     * Initializes the Dynamic Data source manager for a specific component.
+     *
+     * @param component - Component on which the source is being constructed.
+     *
+     * @internal
+     */
+    _initialize(component: BaseComponent, serviceScope: ServiceScope): void;
+    /**
+     * Disposes the resources held by the Dynamic Data source.
+     */
+    dispose(): void;
+    /**
+     * Returns true if the DynamicDataSourceManager is disposed.
+     */
+    get isDisposed(): boolean;
+    /**
+     * Returns the source of DynamicDataSourceManager.
+     * @internal
+     */
+    get _source(): IDynamicDataSource | undefined;
+    /**
+     * Initializes the Dynamic Data Source for the component.
+     *
+     * @param callableFunctions - Set of methods that are exposed through the Dynamic Data Source
+     */
+    initializeSource(callableFunctions: IDynamicDataCallables): void;
+    /**
+     * Notifies that this source has updated its properties.
+     *
+     * When invoked, it enables to broadcast the notification to all the consumers who have
+     * registered to this notification from this source.
+     */
+    notifySourceChanged(): void;
+    /**
+     * Notifies that this source has updated a specific property.
+     *
+     * When invoked, it enables to broadcast the notification to all the consumers who have
+     * registered to this notification from this source.
+     *
+     * @param propertyId - Id of the updated property in the source.
+     */
+    notifyPropertyChanged(propertyId: string): void;
+    /**
+     * Updates the metadata of the Dynamic Data Source.
+     * It allows to update fields like title or description.
+     * Auto-generated fields like alias, componentId or instanceId cannot be updated.
+     *
+     * @param metadata - Partial of the metadata.
+     */
+    updateMetadata(metadata: Partial<IDynamicDataSourceMetadata>): void;
+    /**
+     * Returns the Id of the current DataSource.
+     * If the component did not initialize as a dynamic data source, then it returns an empty string.
+     */
+    get sourceId(): string;
+    private _buildSource;
+    /**
+     * This is the allowedEvents() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     */
+    private _allowedEvents;
+    /**
+     * This is the sendEvent() that the consumer invokes to send an event to the source, with data.
+     * @param eventName - Name of the event
+     * @param data - Associated data
+     */
+    private _sendEvent;
+    /**
+     * This is the getPropertyDefinitions() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     * This assumes that the component has dynamic data and has a controller.
+     */
+    private _getPropertyDefinitions;
+    /**
+     * This is the getPropertyValue() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     * This assumes that the component has the source initialized.
+     * If there is no value returned, it checks whether the propertyId is incorrect or the value is actually undefined.
+     *
+     * @remarks
+     * If the property value associated with the property id, is an array then the
+     * propertyId will have [*] notation appended at the end to support valid JSON Path notation.
+     * Hence when reading the property id, we account for that and extract the name accordingly.
+     */
+    private _getPropertyValue;
+    /**
+     * Returns the real time value of the property.
+     */
+    private _getPropertyDefinitionsAsync;
+    /**
+     * Returns the real time value of the property.
+     * @param propertyId - property id for which the value is requested.
+     */
+    private _getPropertyValueAsync;
+    /**
+     * This is the allowedEvents() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     */
+    private _allowedEventsAsync;
+    /**
+     * This is the getPropertyValueSchema() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     * If the source doesn't provide the annotated value, then it falls back to whatever
+     * 'getPropertyValue' returns as the sample value and metadata would be undefined.
+     *
+     * @remarks
+     * If the property value associated with the property id, is an array then the
+     * propertyId will have [*] notation appended at the end to support valid JSON Path notation.
+     * Hence when reading the property id, we account for that and extract the name accordingly.
+     *
+     * @param propertyId - property id for which the schema is requested.
+     */
+    private _getAnnotatedPropertyValue;
+    /**
+     * Returns the annotated value of the property.
+     * @param propertyId - property id for which the value is requested.
+     */
+    private _getAnnotatedPropertyValueAsync;
+    private _buildMetadata;
+    /**
+     * Asserts if the event is a valid event on the source.
+     *
+     * Its an invalid event in two cases:
+     *  1. When '_allowedEvent()' api returns undefined
+     *  2. When the event name is not one of the allowed events on the source.
+     *
+     * @param eventName - Name of the event.
+     */
+    private _assertValidEvent;
+    private _assertNotDisposed;
+    private _assertInitialized;
+    private _assertSourceExists;
+    /**
+     * Logs a feature event.
+     * @param logFeature - Name of the feature to log.
+     * @param contextualProps - Contextual log properties of the feature event.
+     */
+    private _logFeatureEntry;
+}
+//# sourceMappingURL=DynamicDataSourceManager.d.ts.map

package/lib/DynamicDataSourceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicDataSourceManager.d.ts","sourceRoot":"","sources":["../src/DynamicDataSourceManager.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAkB,MAAM,4BAA4B,CAAC;AACjG,OAAO,EAEL,KAAK,qBAAqB,EAG1B,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAGhC,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,aAAa,MAAM,iBAAiB,CAAC;AAKjD;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,wBAAyB,YAAW,WAAW;IAClE,OAAO,CAAC,mBAAmB,CAAmC;IAC9D,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,IAAI,CAA6C;IACzD,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,UAAU,CAA8D;IAEhF;;;;;;OAMG;IACI,WAAW,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI;IAW9E;;OAEG;IACI,OAAO,IAAI,IAAI;IActB;;OAEG;IACH,IAAW,UAAU,IAAI,OAAO,CAE/B;IAED;;;OAGG;IACH,IAAW,OAAO,IAAI,kBAAkB,GAAG,SAAS,CAEnD;IAED;;;;OAIG;IACI,gBAAgB,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,IAAI;IAmBvE;;;;;OAKG;IACI,mBAAmB,IAAI,IAAI;IAOlC;;;;;;;OAOG;IACI,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAQtD;;;;;;OAMG;IACI,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,0BAA0B,CAAC,GAAG,IAAI;IAc1E;;;OAGG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,OAAO,CAAC,YAAY;IA2BpB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAMtB;;;;OAIG;IAEH,OAAO,CAAC,UAAU;IAMlB;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAI/B;;;;;;;;;;OAUG;IAEH,OAAO,CAAC,iBAAiB;IA2CzB;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAIpC;;;OAGG;IAEH,OAAO,CAAC,sBAAsB;IAI9B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,0BAA0B;IA0ClC;;;OAGG;IACH,OAAO,CAAC,+BAA+B;IAIvC,OAAO,CAAC,cAAc;IAyBtB;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,mBAAmB;IAM3B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAezB"}

package/lib/DynamicDataSourceManager.js

@@ -0,0 +1,382 @@
+import { __assign } from "tslib";
+import { _EngagementLogger, _LogEntry, _LogType, _TraceLogger, _LogSource, _QosMonitor } from '@microsoft/sp-diagnostics';
+import { Text, Validate } from '@microsoft/sp-core-library';
+import { _DynamicDataUtilities } from '@microsoft/sp-dynamic-data';
+import * as lodash from '@microsoft/sp-lodash-subset';
+import { cloneDeep, findIndex, merge } from '@microsoft/sp-lodash-subset';
+import DynamicDataProvider from './DynamicDataProvider';
+import strings from './loc/Strings.resx';
+import { isExemptWebPartWithDynamicDataFromLazyLoadKSActivated } from './common/KillSwitches';
+/**
+ * The Dynamic Data Source Manager is responsible for:
+ *  - Constructing the dynamic data source
+ *  - Allowing initialization of the dynamic data source by a component
+ *  - Allowing data source to update its metadata and notify when data has been updated.
+ *
+ * @public
+ */
+var DynamicDataSourceManager = /** @class */ (function () {
+    function DynamicDataSourceManager() {
+        this._src = undefined;
+        this._isDisposed = false;
+        this._isInitialized = false;
+        this._logSource = _LogSource.create('DynamicDataSourceManager');
+    }
+    /**
+     * Initializes the Dynamic Data source manager for a specific component.
+     *
+     * @param component - Component on which the source is being constructed.
+     *
+     * @internal
+     */
+    DynamicDataSourceManager.prototype._initialize = function (component, serviceScope) {
+        Validate.isNotNullOrUndefined(component, 'component');
+        Validate.isNotNullOrUndefined(serviceScope, 'serviceScope');
+        this._component = component;
+        this._dynamicDataManager = serviceScope.consume(_DynamicDataUtilities.IDynamicDataManagerServiceKey);
+        this._isInitialized = true;
+    };
+    /**
+     * Disposes the resources held by the Dynamic Data source.
+     */
+    DynamicDataSourceManager.prototype.dispose = function () {
+        if (!this._isDisposed) {
+            if (this._src) {
+                this._dynamicDataManager.removeSource(this._src.id);
+                delete this._src;
+            }
+            delete this._dynamicDataManager;
+            delete this._component;
+            this._isInitialized = false;
+            this._isDisposed = true;
+        }
+    };
+    Object.defineProperty(DynamicDataSourceManager.prototype, "isDisposed", {
+        /**
+         * Returns true if the DynamicDataSourceManager is disposed.
+         */
+        get: function () {
+            return this._isDisposed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DynamicDataSourceManager.prototype, "_source", {
+        /**
+         * Returns the source of DynamicDataSourceManager.
+         * @internal
+         */
+        get: function () {
+            return this._src;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Initializes the Dynamic Data Source for the component.
+     *
+     * @param callableFunctions - Set of methods that are exposed through the Dynamic Data Source
+     */
+    DynamicDataSourceManager.prototype.initializeSource = function (callableFunctions) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        if (this._src) {
+            throw new Error(strings.SourceAlreadyInitialized);
+        }
+        this._callableFunctions = callableFunctions;
+        this._src = this._buildSource(this._component);
+        this._dynamicDataManager.addSource(this._src);
+        if (!isExemptWebPartWithDynamicDataFromLazyLoadKSActivated()) {
+            this._component._containsDynamicDataSource = true;
+        }
+        this._logFeatureEntry('DynamicDataSourceInitialized', { sourceId: this._src.id });
+    };
+    /**
+     * Notifies that this source has updated its properties.
+     *
+     * When invoked, it enables to broadcast the notification to all the consumers who have
+     * registered to this notification from this source.
+     */
+    DynamicDataSourceManager.prototype.notifySourceChanged = function () {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        this._assertSourceExists();
+        this._dynamicDataManager.notifySourceChanged(this._src.id);
+    };
+    /**
+     * Notifies that this source has updated a specific property.
+     *
+     * When invoked, it enables to broadcast the notification to all the consumers who have
+     * registered to this notification from this source.
+     *
+     * @param propertyId - Id of the updated property in the source.
+     */
+    DynamicDataSourceManager.prototype.notifyPropertyChanged = function (propertyId) {
+        Validate.isNonemptyString(propertyId, 'propertyId');
+        this._assertNotDisposed();
+        this._assertInitialized();
+        this._assertSourceExists();
+        this._dynamicDataManager.notifyPropertyChanged(this._src.id, propertyId);
+    };
+    /**
+     * Updates the metadata of the Dynamic Data Source.
+     * It allows to update fields like title or description.
+     * Auto-generated fields like alias, componentId or instanceId cannot be updated.
+     *
+     * @param metadata - Partial of the metadata.
+     */
+    DynamicDataSourceManager.prototype.updateMetadata = function (metadata) {
+        this._assertNotDisposed();
+        this._assertInitialized();
+        this._assertSourceExists();
+        Validate.isNotNullOrUndefined(metadata, 'metadata');
+        // Ensure that auto-generated properties are not updated.
+        metadata.alias = undefined;
+        metadata.componentId = undefined;
+        metadata.instanceId = undefined;
+        merge(this._src.metadata, metadata);
+    };
+    Object.defineProperty(DynamicDataSourceManager.prototype, "sourceId", {
+        /**
+         * Returns the Id of the current DataSource.
+         * If the component did not initialize as a dynamic data source, then it returns an empty string.
+         */
+        get: function () {
+            return this._src ? this._src.id : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DynamicDataSourceManager.prototype._buildSource = function (component) {
+        // If the source is returning non-empty allowed events then, it has to define
+        // 'sendEvent' event handler as well.
+        if (this._callableFunctions.allowedEvents && this._callableFunctions.allowedEvents.length > 0) {
+            if (!this._callableFunctions.sendEvent) {
+                throw new Error(strings.NoSendEventWhenAllowedEventsIsNonEmpty);
+            }
+        }
+        return {
+            id: this._component._dynamicDataSourceId,
+            metadata: this._buildMetadata(component),
+            // Return a clone to ensure that the consumer doesn't modify values in the source
+            getPropertyDefinitions: this._getPropertyDefinitions.bind(this),
+            getPropertyValue: this._getPropertyValue.bind(this),
+            getAnnotatedPropertyValue: this._getAnnotatedPropertyValue.bind(this),
+            // async callbacks
+            getPropertyDefinitionsAsync: this._getPropertyDefinitionsAsync.bind(this),
+            getPropertyValueAsync: this._getPropertyValueAsync.bind(this),
+            getAnnotatedPropertyValueAsync: this._getAnnotatedPropertyValueAsync.bind(this),
+            allowedEventsAsync: this._allowedEventsAsync.bind(this),
+            sendEvent: this._sendEvent.bind(this)
+        };
+    };
+    /**
+     * This is the allowedEvents() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     */
+    DynamicDataSourceManager.prototype._allowedEvents = function () {
+        return this._callableFunctions.allowedEvents
+            ? cloneDeep(this._callableFunctions.allowedEvents())
+            : undefined;
+    };
+    /**
+     * This is the sendEvent() that the consumer invokes to send an event to the source, with data.
+     * @param eventName - Name of the event
+     * @param data - Associated data
+     */
+    DynamicDataSourceManager.prototype._sendEvent = function (eventName, data) {
+        this._assertValidEvent(eventName);
+        this._callableFunctions.sendEvent(eventName, data);
+    };
+    /**
+     * This is the getPropertyDefinitions() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     * This assumes that the component has dynamic data and has a controller.
+     */
+    DynamicDataSourceManager.prototype._getPropertyDefinitions = function () {
+        return cloneDeep(this._callableFunctions.getPropertyDefinitions());
+    };
+    /**
+     * This is the getPropertyValue() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     * This assumes that the component has the source initialized.
+     * If there is no value returned, it checks whether the propertyId is incorrect or the value is actually undefined.
+     *
+     * @remarks
+     * If the property value associated with the property id, is an array then the
+     * propertyId will have [*] notation appended at the end to support valid JSON Path notation.
+     * Hence when reading the property id, we account for that and extract the name accordingly.
+     */
+    DynamicDataSourceManager.prototype._getPropertyValue = function (propertyId) {
+        Validate.isNotNullOrUndefined(propertyId, 'propertyId');
+        var qosMonitor = new _QosMonitor('DynamicDataSourceManager._getPropertyValue');
+        var paths = propertyId.split(DynamicDataProvider._jsonPathArrayRegex);
+        try {
+            var propertyValue = this._callableFunctions.getPropertyValue(paths.shift());
+            if (paths.length > 0) {
+                if (!isNaN(parseInt(paths[0], 10)) && Array.isArray(propertyValue)) {
+                    propertyValue = propertyValue[paths[0]];
+                }
+            }
+            if (propertyValue === undefined) {
+                if (
+                // This code can be slow if there is a many property definitions (O(n) for number of properties).
+                // It's done this way to prioritize memory consumption instead of CPU cycles as this is an optional feature,
+                // so if it's not used there is no memory footprint
+                this._callableFunctions.getPropertyDefinitions().filter(function (def) { return def.id === propertyId; }).length ===
+                    0 &&
+                    this._src // Check that the source exists to get its title
+                ) {
+                    throw new Error("Property \"".concat(propertyId, "\" doesn't exist in source \"").concat(this._src.metadata.title, "\""));
+                }
+            }
+            // DO NOT log propertyValue it can contain PII.
+            qosMonitor.writeSuccess(__assign(__assign({}, ((this._src && this._src.metadata) || {})), { sourceId: this._src && this._src.id, propertyId: propertyId }));
+            return cloneDeep(propertyValue);
+        }
+        catch (error) {
+            qosMonitor.writeUnexpectedFailure('NoPropertyId', error, { propertyId: propertyId });
+            _TraceLogger.logErrorData({
+                source: this._logSource,
+                error: error
+            });
+            return undefined;
+        }
+    };
+    /**
+     * Returns the real time value of the property.
+     */
+    DynamicDataSourceManager.prototype._getPropertyDefinitionsAsync = function () {
+        return Promise.resolve(this._getPropertyDefinitions());
+    };
+    /**
+     * Returns the real time value of the property.
+     * @param propertyId - property id for which the value is requested.
+     */
+    DynamicDataSourceManager.prototype._getPropertyValueAsync = function (propertyId) {
+        return Promise.resolve(this._getPropertyValue(propertyId));
+    };
+    /**
+     * This is the allowedEvents() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     */
+    DynamicDataSourceManager.prototype._allowedEventsAsync = function () {
+        return Promise.resolve(this._allowedEvents());
+    };
+    /**
+     * This is the getPropertyValueSchema() that the DynamicDataSource actually exposes.
+     * It does a copy of the data to ensure the consumer doesn't modify the source.
+     * If the source doesn't provide the annotated value, then it falls back to whatever
+     * 'getPropertyValue' returns as the sample value and metadata would be undefined.
+     *
+     * @remarks
+     * If the property value associated with the property id, is an array then the
+     * propertyId will have [*] notation appended at the end to support valid JSON Path notation.
+     * Hence when reading the property id, we account for that and extract the name accordingly.
+     *
+     * @param propertyId - property id for which the schema is requested.
+     */
+    DynamicDataSourceManager.prototype._getAnnotatedPropertyValue = function (propertyId) {
+        Validate.isNotNullOrUndefined(propertyId, 'propertyId');
+        var qosMonitor = new _QosMonitor('DynamicDataSourceManager._getAnnotatedPropertyValue');
+        var annotatedPropertyValue;
+        var getAnnotatedPropertyValue = this._callableFunctions.getAnnotatedPropertyValue;
+        if (getAnnotatedPropertyValue) {
+            var paths = propertyId.split(DynamicDataProvider._jsonPathArrayRegex);
+            try {
+                annotatedPropertyValue = this._callableFunctions.getAnnotatedPropertyValue(paths.shift());
+                if (paths.length > 0) {
+                    if (!isNaN(parseInt(paths[0], 10)) && Array.isArray(annotatedPropertyValue)) {
+                        annotatedPropertyValue = annotatedPropertyValue[paths[0]];
+                    }
+                }
+                qosMonitor.writeSuccess(__assign(__assign({}, ((this._src && this._src.metadata) || {})), { sourceId: this._src && this._src.id, annotatedPropertyValue: annotatedPropertyValue, propertyId: propertyId }));
+            }
+            catch (error) {
+                qosMonitor.writeExpectedFailure('NoAnnotatedPropertyValue', error, { annotatedPropertyValue: annotatedPropertyValue });
+                _TraceLogger.logErrorData({
+                    source: this._logSource,
+                    error: error
+                });
+                annotatedPropertyValue = undefined;
+            }
+        }
+        if (!annotatedPropertyValue) {
+            annotatedPropertyValue = {
+                sampleValue: this._getPropertyValue(propertyId),
+                metadata: undefined
+            };
+        }
+        return annotatedPropertyValue;
+    };
+    /**
+     * Returns the annotated value of the property.
+     * @param propertyId - property id for which the value is requested.
+     */
+    DynamicDataSourceManager.prototype._getAnnotatedPropertyValueAsync = function (propertyId) {
+        return Promise.resolve(this._getAnnotatedPropertyValue(propertyId));
+    };
+    DynamicDataSourceManager.prototype._buildMetadata = function (component) {
+        var metadata = {
+            title: component.manifest.alias,
+            alias: component.manifest.alias,
+            componentId: component.componentId,
+            instanceId: component.instanceId
+        };
+        // Web parts have properties "title" and "description" that should go to the source by default.
+        var componentWithMetadata = component;
+        if (componentWithMetadata.title) {
+            metadata.title = componentWithMetadata.title;
+        }
+        if (componentWithMetadata.description) {
+            metadata.description = componentWithMetadata.description;
+        }
+        return metadata;
+    };
+    /**
+     * Asserts if the event is a valid event on the source.
+     *
+     * Its an invalid event in two cases:
+     *  1. When '_allowedEvent()' api returns undefined
+     *  2. When the event name is not one of the allowed events on the source.
+     *
+     * @param eventName - Name of the event.
+     */
+    DynamicDataSourceManager.prototype._assertValidEvent = function (eventName) {
+        if (!this._allowedEvents() || findIndex(this._allowedEvents(), { name: eventName }) === -1) {
+            throw new Error(Text.format(strings.InvalidEvent, eventName, this._src.metadata.title));
+        }
+    };
+    DynamicDataSourceManager.prototype._assertNotDisposed = function () {
+        if (this.isDisposed) {
+            throw new Error(strings.DynamicDataSourceManagerIsDisposed);
+        }
+    };
+    DynamicDataSourceManager.prototype._assertInitialized = function () {
+        if (!this._isInitialized) {
+            throw new Error(strings.DynamicDataSourceManagerIsNotInitialized);
+        }
+    };
+    DynamicDataSourceManager.prototype._assertSourceExists = function () {
+        if (!this._src) {
+            throw new Error(strings.DynamicDataSourceIsNotInitialized);
+        }
+    };
+    /**
+     * Logs a feature event.
+     * @param logFeature - Name of the feature to log.
+     * @param contextualProps - Contextual log properties of the feature event.
+     */
+    DynamicDataSourceManager.prototype._logFeatureEntry = function (logFeature, contextualProps) {
+        var isInternal = this._component.manifest.isInternal || false;
+        var logProperties = {
+            alias: this._component.manifest.alias,
+            isInternal: isInternal.toString()
+        };
+        var logEntry = new _LogEntry('DynamicDataSourceManager', logFeature, _LogType.Event, lodash.merge(logProperties, contextualProps));
+        _EngagementLogger.logEventWithLogEntry(logEntry);
+    };
+    return DynamicDataSourceManager;
+}());
+export default DynamicDataSourceManager;
+//# sourceMappingURL=DynamicDataSourceManager.js.map