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

package/lib-esm/DynamicProperty.js

@@ -0,0 +1,344 @@
+import * as lodash from '@microsoft/sp-lodash-subset';
+import { _SPKillSwitch, Validate } from '@microsoft/sp-core-library';
+import { DynamicDataReference } from '@microsoft/sp-dynamic-data';
+import DynamicDataProvider from './DynamicDataProvider';
+import { _LogEntry, _EngagementLogger, _LogType } from '@microsoft/sp-diagnostics';
+class DynamicProperty {
+    /**
+   * Sets the value of the DynamicProperty to be a reference to a DynamicDynamicSource
+   * and property.  The reference is of the form `<source>:<property>:<path>`.
+   * @param reference - Id of the DynamicDataSource and property.
+   */ setReference(reference) {
+        Validate.isNonemptyString(reference, 'id');
+        this._value = undefined;
+        this._hasValue = false;
+        // Potentially changing the source. Remove all callbacks, change the source, and add callbacks again.
+        const callbacks = new Set();
+        this._callbacks.forEach((callback)=>callbacks.add(callback));
+        this._callbacks.forEach((callback)=>this.unregister(callback));
+        this._reference = new DynamicDataReference(reference);
+        this._sourceId = this._getSourceId();
+        callbacks.forEach((callback)=>this.register(callback));
+        // The source has changed, so act if a new source was added
+        this._onSourcesChangedCallback();
+    }
+    /**
+   * Sets a static value in the DynamicProperty.
+   * @param value - Value for the DynamicProperty.
+   */ setValue(value) {
+        // Removing the source. Remove all callback, set the value, and add the callback again so they are not lost.
+        // Callbacks will be stored in the pending callbacks list.
+        const callbacks = this._callbacks;
+        callbacks.forEach((callback)=>this.unregister(callback));
+        this._value = value;
+        this._reference = undefined;
+        this._sourceId = undefined;
+        this._hasValue = true;
+        callbacks.forEach((callback)=>this.register(callback));
+    }
+    /**
+   * {@inheritDoc @microsoft/sp-core-library#IDisposable.isDisposed}
+   */ get isDisposed() {
+        return this._isDisposed;
+    }
+    /**
+   * {@inheritDoc @microsoft/sp-core-library#IDisposable.dispose}
+   */ dispose() {
+        if (!this._isDisposed) {
+            this._provider.unregisterAvailableSourcesChanged(this._onSourcesChanged);
+            if (this._defaultCallback) {
+                this.unregister(this._defaultCallback);
+                delete this._defaultCallback;
+            }
+            this._callbacks.forEach((callback)=>this.unregister(callback));
+            delete this._callbacks;
+            delete this._onSourcesChanged;
+            delete this._pendingCallbacks;
+            delete this._provider;
+            delete this._reference;
+            delete this._sourceId;
+            this._isDisposed = true;
+        }
+    }
+    /**
+   * Returns a serializable version of the object.
+   * To be used when `JSON.stringify()` is called on the object (i.e. during Web Part serialization)
+   *
+   * @remarks
+   * This doesn't follow the naming rule for internal methods because the JavaScript engine needs this exact name.
+   *
+   * @internal
+   */ toJSON() {
+        if (this._hasValue) {
+            return {
+                __type: DynamicProperty._TYPE_NAME,
+                value: this._value
+            };
+        } else {
+            return {
+                __type: DynamicProperty._TYPE_NAME,
+                reference: this._reference
+            };
+        }
+    }
+    /**
+   * DynamicDataReference string that the DynamicProperty object points to.
+   * The reference is of the form `<source>:<property>:<path>`.
+   *
+   * @remarks
+   * If the DynamicProperty is set up with static data, this returns undefined.
+   */ get reference() {
+        return this._hasValue ? undefined : this._reference.reference;
+    }
+    /**
+   * Returns the value of the DynamicProperty object, if it has a non-dynamic value.
+   * Used for serialization purposes. The proper API to access the value of the object is `tryGetValue()`
+   *
+   * @internal
+   */ get value() {
+        return this._value;
+    }
+    /**
+   * Returns the value of the object.
+   *
+   * @remarks
+   * If the value is an array, then the first element of the array is returned;
+   * otherwise, the value itself is returned.
+   *
+   * NOTE: This api will never return an array.  To retrieve an array value,
+   * use the {@link DynamicProperty.tryGetValues} API.
+   *
+   * @returns the value associated with the dynamic property or
+   * undefined if the source or the data doesn't exist.
+   */ tryGetValue() {
+        if (this.isDisposed && !_SPKillSwitch.isActivated('413769dc-5e0c-4609-9c86-bdf099fe84e3' /*, '12/02/2021', 'DisposedUndefinedNotException'*/ )) {
+            return undefined;
+        } else {
+            Validate.isNotDisposed(this, 'DynamicData');
+        }
+        let value = this._getData();
+        if (Array.isArray(value)) {
+            value = value[0];
+        }
+        return value;
+    }
+    /**
+   * Returns the value of the object.
+   *
+   * @remarks
+   * If the value is NOT an array, then an array is returned with the value being the single entry;
+   * otherwise, the value itself is returned.  If the property is undefined or cannot be found,
+   * an empty array will be returned.
+   *
+   * NOTE: This api will always return an array and it assumes that the array is homogeneous.
+   * To retrieve a non-array value, use the {@link DynamicProperty.tryGetValue} API.
+   *
+   * @returns the value associated with the dynamic property or
+   * an empty array if the source or the data doesn't exist.
+   */ tryGetValues() {
+        let value = this._getData();
+        // OK, time for some massaging of the return.
+        if (value) {
+            // If there is a value returned, but it isn't an array, create an array and
+            // make this the return value the sole contents of the array
+            if (!Array.isArray(value)) {
+                value = [
+                    value
+                ];
+            }
+        } else {
+            // In this case, we are saying that there is no value.  For this scenario
+            // we simply return an empty array.
+            value = [];
+        }
+        return value;
+    }
+    /**
+   * Returns the DynamicDataSource that the DynamicProperty object refers to.
+   * Returns undefined if the source doesn't exist.
+   */ tryGetSource() {
+        if (this.isDisposed && !_SPKillSwitch.isActivated('413769dc-5e0c-4609-9c86-bdf099fe84e3' /*, '12/02/2021', 'DisposedUndefinedNotException'*/ )) {
+            return undefined;
+        } else {
+            Validate.isNotDisposed(this, 'DynamicData');
+        }
+        return this._hasValue ? undefined : this._provider.tryGetSource(this._sourceId);
+    }
+    /**
+   * Registers a callback function for updates on the associated DynamicDataSource.
+   * @param callback - Callback function to register.
+   */ register(callback) {
+        Validate.isNotDisposed(this, 'DynamicData');
+        if (!this._hasValue && this._sourceId && !!this._provider.tryGetSource(this._sourceId)) {
+            this._provider.registerPropertyChanged(this._sourceId, this._getPropertyToRegister(), callback);
+            this._callbacks.add(callback);
+        } else {
+            this._pendingCallbacks.add(callback);
+        }
+    }
+    /**
+   * Unregisters a callback function for updates on the associated DynamicDataSource.
+   * The callback function must be the same it was registered with.
+   * @param callback - Callback function to unregister.
+   */ unregister(callback) {
+        Validate.isNotDisposed(this, 'DynamicData');
+        if (!this._hasValue && this._sourceId && !!this._provider.tryGetSource(this._sourceId)) {
+            this._provider.unregisterPropertyChanged(this._sourceId, this._getPropertyToRegister(), callback);
+        }
+        this._pendingCallbacks.delete(callback);
+        this._callbacks.delete(callback);
+    }
+    /**
+   * Returns true if the object has a default callback.
+   */ hasDefaultCallback() {
+        return !!this._defaultCallback;
+    }
+    /**
+   * Removes the registration for the default callback.
+   *
+   * @remarks
+   * This can be useful for advanced users who only want their custom callbacks.
+   */ removeDefaultCallback() {
+        if (this._defaultCallback) {
+            this.unregister(this._defaultCallback);
+            this._defaultCallback = undefined;
+        }
+    }
+    /**
+   * Returns the id of the DynamicDataSource if the DynamicProperty has a reference set.
+   *
+   * @internal
+   */ _getSourceId() {
+        Validate.isNotDisposed(this, 'DynamicData');
+        return this._hasValue ? '' : this._reference.sourceId;
+    }
+    /**
+   * Returns the property name of the DynamicDataSource that the DynamicProperty points to.
+   *
+   * NOTE: This is accessed from the property pane code while building the DynamicDataWidget.
+   * @internal
+   */ _getProperty() {
+        Validate.isNotDisposed(this, 'DynamicData');
+        return this._hasValue ? '' : this._reference.property;
+    }
+    /**
+   * Returns the path from the property that the object points to, if applicable.
+   * If not applicable, returns an empty string.
+   *
+   * @internal
+   */ _getPropertyPath() {
+        Validate.isNotDisposed(this, 'DynamicData');
+        return this._hasValue ? '' : this._reference.propertyPath || '';
+    }
+    /**
+   * Returns a deep cloned version of the current instance.
+   *
+   * @remarks
+   * Since the dynamic property is maintaining an instance of the DynamicDataProvider,
+   * which which when serialized will result in 'Maximum call stack size exceeded' based
+   * on what kind of sources they hold references to.
+   *
+   * For example, if the dynamicDataProvider is holding PageContext source, which internally
+   * has serviceScope in its state. Deep cloning this source would result in the above mentioned
+   * error.
+   *
+   * Hence we would want to just clone the dynamicDataProvider not deep clone it.
+   *
+   * @returns - Custom deep Cloned version of the current instance.
+   *
+   * @internal
+   */ _cloneDeep(instance) {
+        return lodash.cloneDeepWith(instance, (prop)=>{
+            if (prop instanceof DynamicDataProvider) {
+                return prop;
+            }
+        });
+    }
+    /**
+   * Returns the property name of the DynamicDataSource that the DynamicProperty points to.
+   *
+   * @remarks
+   * Removes the array notation from the property name, if any, before it is being registered.
+   * This is to avoid any mismatch between the strings passed by the source when it notifies
+   * a property change, as the source doesn't pass any array notation with the property name.
+   * Array notation is only for internal representation, for a property whose value is an array type.
+   */ _getPropertyToRegister() {
+        Validate.isNotDisposed(this, 'DynamicData');
+        // Split the property string on the array notation to get
+        // the property name. If the array notation is not present,
+        // then the original string is returned in the array.
+        return this._getProperty().split(DynamicProperty._arrayRegex)[0];
+    }
+    /**
+   * Callback when the DynamicDataSources list changes.
+   * It registers the pending callbacks into the DynamicDataProvidere.
+   */ _onSourcesChangedCallback() {
+        if (!this._hasValue && this._sourceId && !!this._provider.tryGetSource(this._sourceId)) {
+            const callbacksToAdd = this._pendingCallbacks;
+            this._pendingCallbacks = new Set();
+            callbacksToAdd.forEach((callback)=>{
+                this.register(callback);
+                callback();
+            });
+        }
+    }
+    _getData() {
+        if (this.isDisposed && !_SPKillSwitch.isActivated('413769dc-5e0c-4609-9c86-bdf099fe84e3' /*, '12/02/2021', 'DisposedUndefinedNotException'*/ )) {
+            return undefined;
+        } else {
+            Validate.isNotDisposed(this, 'DynamicData');
+        }
+        let value;
+        try {
+            value = this._hasValue ? this._value : this._provider._getData(this._reference);
+        } catch (error) {
+            _EngagementLogger.logEventWithLogEntry(error);
+            throw error;
+        }
+        _EngagementLogger.logEventWithLogEntry(new _LogEntry('DynamicData', 'getData', _LogType.Event, {
+            value: JSON.stringify(this.value)
+        }));
+        return value;
+    }
+    /**
+   * Create a new DynamicProperty object.
+   * @param provider - DynamicDataProvider.
+   * @param callback - Optional. Default callback to be registered for updates in the DynamicDataSource.
+   */ constructor(provider, callback){
+        this._hasValue = false;
+        this._isDisposed = false;
+        Validate.isNotNullOrUndefined(provider, 'provider');
+        this['__type'] = DynamicProperty._TYPE_NAME;
+        this._provider = provider;
+        this._callbacks = new Set();
+        this._pendingCallbacks = new Set();
+        if (callback) {
+            // The default callback will be added once a source is configured
+            this._pendingCallbacks.add(callback);
+            this._defaultCallback = callback;
+        } else {
+            this._defaultCallback = undefined;
+        }
+        this._onSourcesChanged = this._onSourcesChangedCallback.bind(this);
+        this._cloneDeep = this._cloneDeep.bind(this);
+        this._provider.registerAvailableSourcesChanged(this._onSourcesChanged);
+    }
+}
+/**
+   * Constant with the type name of the DynamicProperty.
+   * @internal
+   */ DynamicProperty._TYPE_NAME = 'DynamicProperty';
+DynamicProperty._arrayRegex = new RegExp(/\[\*\]$/);
+/**
+ * Serializable object that simplifies usage of a DynamicProperty.
+ *
+ * @remarks
+ * This is built for usage in web part properties, and modified through the property pane.
+ * Can be initialized with a default callback.
+ * Web parts initialize with the render method so if the 3rd party developer does nothing, a change in the
+ * DynamicProperty will re-render the web part automatically.
+ *
+ * @public
+ */ export { DynamicProperty as default };
+
+//# sourceMappingURL=./DynamicProperty.js.map

package/{lib → lib-esm}/EnsureIsolatedDomainUrl.js

@@ -1,26 +1,26 @@
-var domainRegex = new RegExp('^https://[^/]*/');
+const domainRegex = new RegExp('^https://[^/]*/');
 /**
  * Creates an absolute url with the isolatedDomain parameter.
  * @param isolatedDomain - a domain without the protocol. Ex: "PrepSPO-appFEEAB5CE1CB0421FB1AAE5D09E0A8AAA.spgrid.com"
  * @param absoluteUrl - url with protocol that may or may not contain a path. Ex: "https://prepspo.spgrid.com"
  *
  * @internal
- */
-export function ensureIsolatedDomainUrl(isolatedDomain, absoluteUrl) {
+ */ export function ensureIsolatedDomainUrl(isolatedDomain, absoluteUrl) {
     if (!isolatedDomain) {
         return absoluteUrl;
     }
     // replace the domain in "https://domain/path" with isolatedDomain
-    var slashAdded = false;
+    let slashAdded = false;
     if (absoluteUrl.charAt(absoluteUrl.length - 1) !== '/') {
         absoluteUrl = absoluteUrl + '/';
         slashAdded = true;
     }
-    absoluteUrl = absoluteUrl.replace(domainRegex, "https://".concat(isolatedDomain, "/"));
+    absoluteUrl = absoluteUrl.replace(domainRegex, `https://${isolatedDomain}/`);
     if (slashAdded) {
         // Remove the ending slash
         absoluteUrl = absoluteUrl.substr(0, absoluteUrl.length - 1);
     }
     return absoluteUrl;
 }
-//# sourceMappingURL=EnsureIsolatedDomainUrl.js.map
+
+//# sourceMappingURL=./EnsureIsolatedDomainUrl.js.map

package/lib-esm/IComponentPosition.js

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

package/lib-esm/IComponentPropertyMetadata.js

@@ -0,0 +1,7 @@
+/**
+ * This is the structure used for map values for component properties metadata.
+ *
+ * @public
+ */ export { };
+
+//# sourceMappingURL=./IComponentPropertyMetadata.js.map

package/lib-esm/ISerializedServerProcessedData.js

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft. All rights reserved.
+/**
+ * Server processed data type.
+ *
+ * @internal
+ */ // eslint-disable-next-line @typescript-eslint/typedef
+export const ServerProcessedDataType = {
+    /**
+   * The date type is valid html string.
+   */ htmlString: 1,
+    /**
+   * The date type is a link to a resource.
+   * The link can be a SharePoint content link or non-SharePoint link.
+   */ link: 2,
+    /**
+   * The date type is a link to a image.
+   * The link can be a SharePoint content link or non-SharePoint link.
+   */ imageSource: 3,
+    /**
+   * The data type is a string that should be search indexed.
+   */ searchablePlainText: 4
+};
+
+//# sourceMappingURL=./ISerializedServerProcessedData.js.map

package/lib-esm/LegacyThirdPartyFabricCoreLoader.js

@@ -0,0 +1,76 @@
+import { Version } from '@microsoft/sp-core-library';
+class LegacyThirdPartyFabricCoreLoader {
+    /**
+   * Method to dynamically load the legacy third-party fabric core styles.
+   * This method should be called only when a third-party component(web part or extension)
+   * is being loaded on to the page.
+   *
+   * NOTE: Remove this method when the below killswitch is graduated from \@microsoft/sp-webpart-base.
+   * 'isStopLoadingLegacyFabricCSSKillSwitchActivated' - '57b771ed-2b57-41c2-aaaa-0e21c587c6dc'
+   *
+   * @param isComponentInternal - indicates whether the requesting component is internal to Microsoft or not.
+   */ static load(isComponentInternal) {
+        if (!isComponentInternal && !LegacyThirdPartyFabricCoreLoader._isLoaded) {
+            return import(/* webpackChunkName: 'legacy-third-party-fabric-core-localfont' */ './chunks/legacy-third-party-fabric-core/FabricLocalFont').then(()=>{
+                LegacyThirdPartyFabricCoreLoader._isLoaded = true;
+                return;
+            });
+        } else {
+            return Promise.resolve();
+        }
+    }
+    /**
+   * Method to dynamically force load the legacy third-party fabric core styles.
+   * All the below conditions are checked and needs to be true to force load the legacy css:
+   *   1. Should be third party component (web part or extension)
+   *   2. Should not be already loaded
+   *   3. Component should ask to load the legacy css or if the component is built version \< 1.8
+   *
+   * @param manifest - component's manifest
+   */ static forceLoad(manifest) {
+        try {
+            if (LegacyThirdPartyFabricCoreLoader._shouldLoad(manifest)) {
+                return import(/* webpackChunkName: 'legacy-third-party-fabric-core-localfont' */ './chunks/legacy-third-party-fabric-core/FabricLocalFont').then(()=>{
+                    LegacyThirdPartyFabricCoreLoader._isLoaded = true;
+                    return;
+                });
+            } else {
+                return Promise.resolve();
+            }
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+   * Method to check if the web part need to load the legacy css.
+   * @param manifest - component's manifest
+   */ static needLegacyFabricCss(manifest) {
+        if (manifest.isInternal) {
+            return false;
+        }
+        /*
+     * If loadLegacyFabricCss is not specified by the component, then load the css
+     * if the component is built before SPFx 1.8.2 or in some cases when we cannot get
+     * the version of the SPFx.
+     */ if (manifest.loadLegacyFabricCss === undefined) {
+            const version = Version._tryParseSPFxVersion(manifest);
+            return !version || version.lessThan(Version.parse('1.8.2'));
+        }
+        // Respect 'loadLegacyFabricCss' if a real value is provided.
+        return manifest.loadLegacyFabricCss;
+    }
+    static _shouldLoad(manifest) {
+        return !LegacyThirdPartyFabricCoreLoader._isLoaded && LegacyThirdPartyFabricCoreLoader.needLegacyFabricCss(manifest);
+    }
+}
+/**
+   * Indicates whether the fabric-core styles are loaded on the page or not.
+   */ LegacyThirdPartyFabricCoreLoader._isLoaded = false;
+// Copyright (c) Microsoft. All rights reserved.
+/**
+ * Class to load async chunks.
+ *
+ * @internal
+ */ export { LegacyThirdPartyFabricCoreLoader as default };
+
+//# sourceMappingURL=./LegacyThirdPartyFabricCoreLoader.js.map