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

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

@@ -8,43 +8,34 @@ import { SafeHtml } from '@msinternal/sp-safehtml';
  * based on component metadata.
  *
  * @internal
- */
-var PropertyMetadataProcessor = /** @class */ (function () {
-    function PropertyMetadataProcessor() {
-    }
+ */ export class PropertyMetadataProcessor {
     /**
-     * Serialize the properties into server processed content as declared in metadata.
-     *
-     * @param propertiesMetadata - The component properties metadata.
-     * @param properties - The component properties. This object will be modified during serialization.
-     * @param serverProcessedContent - The serialized server processed content. This object will be modified.
-     */
-    PropertyMetadataProcessor.serializeServerProcessedData = function (propertiesMetadata, properties, serverProcessedContent) {
-        var _this = this;
-        this._forEachPropertyWithMetaData(propertiesMetadata, properties, function (propPath, metadata, iteration) {
+   * Serialize the properties into server processed content as declared in metadata.
+   *
+   * @param propertiesMetadata - The component properties metadata.
+   * @param properties - The component properties. This object will be modified during serialization.
+   * @param serverProcessedContent - The serialized server processed content. This object will be modified.
+   */ static serializeServerProcessedData(propertiesMetadata, properties, serverProcessedContent) {
+        this._forEachPropertyWithMetaData(propertiesMetadata, properties, (propPath, metadata, iteration)=>{
             // Remove fields with shouldNotPersist metadata
             if (metadata.shouldNotPersist) {
                 lodash.set(properties, propPath, undefined);
             }
             // Use the property path as the key in server-processed content maps
-            var key = propPath;
+            const key = propPath;
             // WARNING: This is critical code. Please do not modify without fully understanding the data pipeline
-            var value = lodash.get(properties, propPath);
+            const value = lodash.get(properties, propPath);
             // Skip if the property is non-string or undefined
             if (serverProcessedContent && typeof value === 'string' && value) {
                 if (serverProcessedContent.htmlStrings && metadata.isHtmlString) {
                     serverProcessedContent.htmlStrings[key] = value;
-                }
-                else if (serverProcessedContent.searchablePlainTexts && metadata.isSearchablePlainText) {
+                } else if (serverProcessedContent.searchablePlainTexts && metadata.isSearchablePlainText) {
                     serverProcessedContent.searchablePlainTexts[key] = value;
-                }
-                else if (serverProcessedContent.links && metadata.isLink) {
+                } else if (serverProcessedContent.links && metadata.isLink) {
                     serverProcessedContent.links[key] = value;
-                }
-                else if (serverProcessedContent.imageSources && metadata.isImageSource) {
+                } else if (serverProcessedContent.imageSources && metadata.isImageSource) {
                     serverProcessedContent.imageSources[key] = value;
-                }
-                else if (metadata.isComponentDependency) {
+                } else if (metadata.isComponentDependency) {
                     if (!serverProcessedContent.componentDependencies) {
                         serverProcessedContent.componentDependencies = {};
                     }
@@ -52,65 +43,58 @@ var PropertyMetadataProcessor = /** @class */ (function () {
                 }
                 if (metadata.customMetadata) {
                     // Build custom metadata for the given property path
-                    var customMetadata_1 = {};
+                    const customMetadata = {};
                     if (metadata && metadata.customMetadata) {
-                        var _loop_1 = function (propName, customMetadataPropPath) {
-                            var normalizedCustomMetadataPropPath = customMetadataPropPath;
+                        for (const [propName, customMetadataPropPath] of Object.entries(metadata.customMetadata)){
+                            let normalizedCustomMetadataPropPath = customMetadataPropPath;
                             if (iteration !== undefined && normalizedCustomMetadataPropPath.indexOf('*') !== -1) {
                                 // Custom metadata should be resolved with current iteration of wildcard
                                 normalizedCustomMetadataPropPath = normalizedCustomMetadataPropPath.replace('*', iteration.toString());
                             }
-                            _this._validateAndIteratePath(normalizedCustomMetadataPropPath, properties, function (fixedPropPath, customIteration) {
+                            this._validateAndIteratePath(normalizedCustomMetadataPropPath, properties, (fixedPropPath, customIteration)=>{
                                 // Custom metadata should be resolved without iteration
                                 if (customIteration === undefined && metadata.customMetadata) {
-                                    var customValue = lodash.get(properties, fixedPropPath);
+                                    const customValue = lodash.get(properties, fixedPropPath);
                                     if (serverProcessedContent && customValue !== undefined) {
                                         // Insert custom metadata key and value
                                         if (isFixCustomMetadataKeyKillSwitchActivated()) {
-                                            customMetadata_1[fixedPropPath] = customValue;
-                                        }
-                                        else {
-                                            customMetadata_1[propName] = customValue;
+                                            customMetadata[fixedPropPath] = customValue;
+                                        } else {
+                                            customMetadata[propName] = customValue;
                                         }
                                     }
                                 }
                             });
-                        };
-                        for (var _i = 0, _a = Object.entries(metadata.customMetadata); _i < _a.length; _i++) {
-                            var _b = _a[_i], propName = _b[0], customMetadataPropPath = _b[1];
-                            _loop_1(propName, customMetadataPropPath);
                         }
                     }
                     if (!serverProcessedContent.customMetadata) {
                         serverProcessedContent.customMetadata = {};
                     }
                     // Store serialized custom metadata for the given the property path.
-                    serverProcessedContent.customMetadata[key] = customMetadata_1;
+                    serverProcessedContent.customMetadata[key] = customMetadata;
                 }
                 // Unset the extracted property to avoid duplication
                 lodash.set(properties, propPath, undefined);
             }
         });
-    };
+    }
     /**
-     * Reapply the serialized server processed content on the properties based on the metadata.
-     * This process will result in the properties bag as it was when the serialization happened.
-     *
-     * @param propertiesMetadata - The component properties metadata.
-     * @param properties - The component properties. This object will be modified during serialization.
-     * @param serverProcessedContent - The serialized server processed content.
-     * @param manifest - The optional component manifest.
-     */
-    PropertyMetadataProcessor.reInstateServerProcessedData = function (propertiesMetadata, properties, serverProcessedContent, manifest) {
-        var _this = this;
-        var propertyPathsNotInServerProcessedContent = new Set();
+   * Reapply the serialized server processed content on the properties based on the metadata.
+   * This process will result in the properties bag as it was when the serialization happened.
+   *
+   * @param propertiesMetadata - The component properties metadata.
+   * @param properties - The component properties. This object will be modified during serialization.
+   * @param serverProcessedContent - The serialized server processed content.
+   * @param manifest - The optional component manifest.
+   */ static reInstateServerProcessedData(propertiesMetadata, properties, serverProcessedContent, manifest) {
+        const propertyPathsNotInServerProcessedContent = new Set();
         if (manifest) {
             // @privateRemarks Clear out the properties with isHtmlString metadata for security reasons. We only want to
             // propagate values from the serverProcessed content as they are security sanitized by the server. Note, there is a
             // scenario when an end user can update the list item with whatever data they like. In that case, they can
             // eliminate the serverProcessed content and that can cause a potential security hole. Hence, we always want
             // clear out the property values that have isHtmlString metadata.
-            this._forEachPropertyWithMetaData(propertiesMetadata, properties, function (propPath, metadata) {
+            this._forEachPropertyWithMetaData(propertiesMetadata, properties, (propPath, metadata)=>{
                 if (!isServerPropertiesSanitizedEnabled()) {
                     // This is a temporary hack to make sure that the webparts published using the Mobile app keep rendering.
                     // Currently, for those pages, the DocumentEmbedWebPart does not have HTMLProperties pupulated. Hence,
@@ -119,8 +103,7 @@ var PropertyMetadataProcessor = /** @class */ (function () {
                     if (manifest.id !== 'b7dd04e1-19ce-4b24-9132-b60a1c2b910d' && metadata.isHtmlString) {
                         lodash.set(properties, propPath, undefined);
                     }
-                }
-                else {
+                } else {
                     // We should always sanitize the deserialized property bag for any property
                     // that is marked with propertiesMetadata. It is possible for the content to have been
                     // modified at rest and therefore work around the assumption of the serverProcessedContent
@@ -131,24 +114,23 @@ var PropertyMetadataProcessor = /** @class */ (function () {
                     // if the data has been incorrectly modified at rest. The web part is expected to handle that.
                     //
                     // If the path is already undefined then we can skip setting to undefined and the enforcement
-                    if (manifest.id === 'b7dd04e1-19ce-4b24-9132-b60a1c2b910d' &&
-                        _SPKillSwitch.isActivated('71b68bd4-eb7a-4330-93bd-dc6d382123c1' /* '9/28/2023', 'Do not serverProcessContent sanitization for DocumentEmbedWebPart' */)) {
+                    if (manifest.id === 'b7dd04e1-19ce-4b24-9132-b60a1c2b910d' && _SPKillSwitch.isActivated('71b68bd4-eb7a-4330-93bd-dc6d382123c1' /* '9/28/2023', 'Do not serverProcessContent sanitization for DocumentEmbedWebPart' */ )) {
                         return;
                     }
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    var propValue = lodash.get(properties, propPath);
+                    const propValue = lodash.get(properties, propPath);
                     if (propValue !== undefined) {
-                        var qosMonitor = new _QosMonitor('PropertyMetadataProcessor.clearMetadataValue');
+                        const qosMonitor = new _QosMonitor('PropertyMetadataProcessor.clearMetadataValue');
                         if (metadata.isLink) {
                             propertyPathsNotInServerProcessedContent.add(propPath);
-                            if (!_this._isSafeLink(propValue)) {
+                            if (!this._isSafeLink(propValue)) {
                                 qosMonitor.writeUnexpectedFailure('ClearingLinkProperty', new Error(propPath));
                                 lodash.set(properties, propPath, undefined);
                             }
                         }
                         if (metadata.isHtmlString) {
                             propertyPathsNotInServerProcessedContent.add(propPath);
-                            var safeHtml = _this._getSafeHtml(propValue);
+                            const safeHtml = this._getSafeHtml(propValue);
                             if (safeHtml !== propValue) {
                                 qosMonitor.writeUnexpectedFailure('SettingSafeHtml', new Error(propPath));
                                 lodash.set(properties, propPath, safeHtml);
@@ -168,18 +150,16 @@ var PropertyMetadataProcessor = /** @class */ (function () {
             // back to the web part that has the same shape as when the serialization happened.
             // CustomMetadata is only processed on the server so we do not round trip the data back
             // into the web part properties.  This is by design of the feature
-            var htmlMaps = [
+            const htmlMaps = [
                 serverProcessedContent.htmlStrings,
                 serverProcessedContent.searchablePlainTexts,
                 serverProcessedContent.imageSources,
                 serverProcessedContent.links,
                 serverProcessedContent.componentDependencies
             ];
-            for (var _i = 0, htmlMaps_1 = htmlMaps; _i < htmlMaps_1.length; _i++) {
-                var htmlMap = htmlMaps_1[_i];
+            for (const htmlMap of htmlMaps){
                 if (htmlMap) {
-                    for (var _a = 0, _b = Object.entries(htmlMap); _a < _b.length; _a++) {
-                        var _c = _b[_a], propPath = _c[0], value = _c[1];
+                    for (const [propPath, value] of Object.entries(htmlMap)){
                         // WARNING: This is critical code. Please do not modify without fully understanding the data pipeline
                         if (typeof value === 'string') {
                             lodash.set(properties, propPath, value);
@@ -191,107 +171,92 @@ var PropertyMetadataProcessor = /** @class */ (function () {
                 }
             }
         }
-        if (isServerPropertiesSanitizedEnabled() &&
-            manifest &&
-            propertyPathsNotInServerProcessedContent.size > 0) {
-            var logServerPropertiesMissing = new _QosMonitor('PropertyMetadataProcessor.serverProcessedContentMissing');
+        if (isServerPropertiesSanitizedEnabled() && manifest && propertyPathsNotInServerProcessedContent.size > 0) {
+            const logServerPropertiesMissing = new _QosMonitor('PropertyMetadataProcessor.serverProcessedContentMissing');
             logServerPropertiesMissing.writeUnexpectedFailure('Missing Content', undefined, {
                 manifest: manifest.id,
                 properties: Array.from(propertyPathsNotInServerProcessedContent).join(',')
             });
         }
-    };
-    PropertyMetadataProcessor._isSafeLink = function (link) {
+    }
+    static _isSafeLink(link) {
         try {
-            var safeLinkUrl = new URL(link);
+            const safeLinkUrl = new URL(link);
             return SafeHtml.isSafeLinkProtocol(safeLinkUrl.protocol);
-        }
-        catch (_a) {
+        } catch  {
             try {
-                var safeLinkUrl = new URL(link, window.location.origin);
+                const safeLinkUrl = new URL(link, window.location.origin);
                 return SafeHtml.isSafeLinkProtocol(safeLinkUrl.protocol);
-            }
-            catch (_b) {
+            } catch  {
                 return false;
             }
         }
-    };
-    PropertyMetadataProcessor._getSafeHtml = function (html) {
+    }
+    static _getSafeHtml(html) {
         return SafeHtml.clean(html);
-    };
+    }
     /**
-     * Iterates and validates each metadata property before calling metadata processor.
-     *
-     * @param propertiesMetadata - Component properties metadata.
-     * @param properties - Component properties.
-     * @param metadataProcessor - Callback handler to to process validated metadata.
-     *
-     * @internal
-     */
-    PropertyMetadataProcessor._forEachPropertyWithMetaData = function (propertiesMetadata, properties, metadataProcessor) {
+   * Iterates and validates each metadata property before calling metadata processor.
+   *
+   * @param propertiesMetadata - Component properties metadata.
+   * @param properties - Component properties.
+   * @param metadataProcessor - Callback handler to to process validated metadata.
+   *
+   * @internal
+   */ static _forEachPropertyWithMetaData(propertiesMetadata, properties, metadataProcessor) {
         if (propertiesMetadata) {
-            var _loop_2 = function (propPath, metadata) {
-                this_1._validateAndIteratePath(propPath, properties, function (fixedPropPath, index) {
+            for (const [propPath, metadata] of Object.entries(propertiesMetadata)){
+                this._validateAndIteratePath(propPath, properties, (fixedPropPath, index)=>{
                     metadataProcessor(fixedPropPath, metadata, index);
                 });
-            };
-            var this_1 = this;
-            for (var _i = 0, _a = Object.entries(propertiesMetadata); _i < _a.length; _i++) {
-                var _b = _a[_i], propPath = _b[0], metadata = _b[1];
-                _loop_2(propPath, metadata);
             }
         }
-    };
+    }
     /**
-     * Validates path and iterate over one or multiple wildcard paths
-     *
-     * @param propPath - Original property path provided in metadata
-     * @param properties - Properties to look for the given path.
-     * @param propertyPathHandler - Handler to process validated and fixed path
-     */
-    PropertyMetadataProcessor._validateAndIteratePath = function (propPath, properties, propertyPathHandler) {
-        var wildcardCount = (propPath.match(/\*/g) || []).length;
+   * Validates path and iterate over one or multiple wildcard paths
+   *
+   * @param propPath - Original property path provided in metadata
+   * @param properties - Properties to look for the given path.
+   * @param propertyPathHandler - Handler to process validated and fixed path
+   */ static _validateAndIteratePath(propPath, properties, propertyPathHandler) {
+        const wildcardCount = (propPath.match(/\*/g) || []).length;
         if (wildcardCount > 1) {
             // Skip if there are more than one asterisks in the path (not supported)
             // eslint-disable-next-line no-console
-            console.warn("Invalid property path: Multiple wildcards are not supported in property paths.\nEntry with path '".concat(propPath, "' got ignored in the properties metadata."));
+            console.warn(`Invalid property path: Multiple wildcards are not supported in property paths.
+Entry with path '${propPath}' got ignored in the properties metadata.`);
             return;
-        }
-        else if (wildcardCount === 1) {
-            var index = propPath.indexOf('[*]');
+        } else if (wildcardCount === 1) {
+            const index = propPath.indexOf('[*]');
             if (index < -1) {
                 // eslint-disable-next-line no-console
-                console.warn("Invalid property path: Wildcards are only supported inside brackets to select array\nindices as in 'foo[*].bar'. Entry with path '".concat(propPath, "' got ignored in the properties metadata."));
+                console.warn(`Invalid property path: Wildcards are only supported inside brackets to select array
+indices as in 'foo[*].bar'. Entry with path '${propPath}' got ignored in the properties metadata.`);
                 // Skip if the wildcard is not used for an array (not supported)
                 return;
-            }
-            else {
+            } else {
                 // Handle the array wildcard by generating each individual property path
-                var arrayPath = propPath.substr(0, index);
-                var arrayInstance = lodash.get(properties, arrayPath);
+                const arrayPath = propPath.substr(0, index);
+                const arrayInstance = lodash.get(properties, arrayPath);
                 if (!arrayInstance) {
                     // eslint-disable-next-line no-console
-                    console.warn("Invalid property path: Could not find an array named '".concat(arrayPath, "' in the properties.\nEntry with path '").concat(propPath, "' got ignored in the properties metadata."));
+                    console.warn(`Invalid property path: Could not find an array named '${arrayPath}' in the properties.
+Entry with path '${propPath}' got ignored in the properties metadata.`);
                     return;
-                }
-                else {
-                    for (var i = 0; i < arrayInstance.length; i++) {
-                        var fixedPropPath = propPath.replace('*', "".concat(i));
+                } else {
+                    for(let i = 0; i < arrayInstance.length; i++){
+                        const fixedPropPath = propPath.replace('*', `${i}`);
                         propertyPathHandler(fixedPropPath, i);
                     }
                 }
             }
-        }
-        else {
+        } else {
             propertyPathHandler(propPath);
         }
-    };
-    return PropertyMetadataProcessor;
-}());
-export { PropertyMetadataProcessor };
+    }
+}
 function isFixCustomMetadataKeyKillSwitchActivated() {
-    return _SPKillSwitch.isActivated('bf085c27-422d-4b62-a93a-43efa89e77ee'
-    /* '2022-03-28', 'Fix custom metadata key' */
-    );
+    return _SPKillSwitch.isActivated('bf085c27-422d-4b62-a93a-43efa89e77ee');
 }
-//# sourceMappingURL=PropertyMetadataProcessor.js.map
+
+//# sourceMappingURL=./PropertyMetadataProcessor.js.map

package/lib-esm/RenderableComponentContext.js

@@ -0,0 +1,26 @@
+import { Validate, _ES5CompatibleClass } from '@microsoft/sp-core-library';
+import BaseComponentContext from './BaseComponentContext';
+/**
+ * Base context for component types that render into a DOM element — web parts,
+ * Copilot Components, and any future renderable component type.
+ *
+ * @remarks
+ * Extends {@link @microsoft/sp-component-base#BaseComponentContext} with a
+ * {@link RenderableComponentContext.domElement | domElement} property. Component
+ * types that do not have a dedicated render target (e.g. application
+ * customizers, extensions) should continue to extend `BaseComponentContext`
+ * directly.
+ *
+ * @public
+ */ class RenderableComponentContext extends BaseComponentContext {
+    /** @internal */ constructor(parameters){
+        const { domElement, ...superParameters } = parameters;
+        super(superParameters);
+        Validate.isNotNullOrUndefined(domElement, 'domElement');
+        this.domElement = domElement;
+    }
+}
+_ES5CompatibleClass(RenderableComponentContext);
+export default RenderableComponentContext;
+
+//# sourceMappingURL=./RenderableComponentContext.js.map

package/lib-esm/ShimmerFactory.js

@@ -0,0 +1,74 @@
+import styles from './styles/shimmer.module.scss';
+// These constants are taken from generic shimmer design.
+const SHIMMER_WIDTH_DEFAULT = 100;
+const SHIMMER_HEIGHT_DEFAULT = 100;
+const SHIMMER_RECTANGLE_HEIGHT_MAX = 16;
+const SHIMMER_RECTANGLE_COUNT = 4;
+const SHIMMER_ELEMENT_COUNT = 2 * SHIMMER_RECTANGLE_COUNT + 1;
+const RECTANGLE_X = 8;
+const SHIMMER_MAIN_RECTANGLE_SIZE_RATIO = 0.9;
+const RECTANGLE_1_LENGTH = 20;
+const RECTANGLE_2_LENGTH = 40;
+const RECTANGLE_3_LENGTH = 90;
+const RECTANGLE_4_LENGTH = 80;
+class ShimmerFactory {
+    /**
+   *  Method that creates a shimmer for applications using an svg.
+   * @param width - Width of the shimmer
+   * @param height - Height of the shimmer
+   * @param componentTag - ID for the shimmer
+   * @param loadingMessage - Displays message when the shimmer loads
+   */ static createShimmer(width, height, componentTag, loadingMessage, containerMargin = undefined) {
+        width = width || SHIMMER_WIDTH_DEFAULT;
+        height = height || SHIMMER_HEIGHT_DEFAULT;
+        const shimmerContainerDiv = document.createElement('div');
+        shimmerContainerDiv.className = styles.shimmerContainer;
+        const shimmerDiv = document.createElement('div');
+        const mainRectangleHeight = height * SHIMMER_MAIN_RECTANGLE_SIZE_RATIO;
+        let rectangleHeight = mainRectangleHeight / SHIMMER_ELEMENT_COUNT;
+        rectangleHeight = Math.min(SHIMMER_RECTANGLE_HEIGHT_MAX, rectangleHeight);
+        const gap = 2 * rectangleHeight;
+        const rectangle1Y = rectangleHeight;
+        const rectangle2Y = rectangle1Y + gap;
+        const rectangle3Y = rectangle2Y + gap;
+        const rectangle4Y = rectangle3Y + gap;
+        const className = styles.shimmerElementFill;
+        shimmerDiv.innerHTML = `<svg width=${width} height=${height} viewBox="0 0 ${width} ${height}" version="1.1"
+        xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+        <title>${loadingMessage}</title>
+        <g id=${componentTag}_Shimmer stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+          <rect x="0" y="0" width=${width} height=${height}></rect>
+          ${ShimmerFactory._shimmerRect(componentTag + '_1', className, RECTANGLE_X, rectangle1Y, RECTANGLE_1_LENGTH, rectangleHeight)}
+          ${ShimmerFactory._shimmerRect(componentTag + '_2', className, RECTANGLE_X, rectangle2Y, RECTANGLE_2_LENGTH, rectangleHeight)}
+          ${ShimmerFactory._shimmerRect(componentTag + '_3', className, RECTANGLE_X, rectangle3Y, RECTANGLE_3_LENGTH, rectangleHeight)}
+          ${ShimmerFactory._shimmerRect(componentTag + '_4', className, RECTANGLE_X, rectangle4Y, RECTANGLE_4_LENGTH, rectangleHeight)}
+        </g>
+      </svg>`;
+        if (containerMargin !== undefined) {
+            shimmerContainerDiv.style.margin = containerMargin + '';
+        }
+        shimmerContainerDiv.appendChild(shimmerDiv);
+        const shimmerAccessibilityContainerDiv = document.createElement('div');
+        shimmerAccessibilityContainerDiv.setAttribute('role', 'status');
+        shimmerAccessibilityContainerDiv.setAttribute('aria-live', 'polite');
+        shimmerContainerDiv.appendChild(shimmerAccessibilityContainerDiv);
+        return shimmerContainerDiv;
+    }
+    static _shimmerRect(id, className, x, y, width, height) {
+        return `<rect id=${id} class=${className} x=${x} y=${y} width="${width}%" height=${height}>
+      <animate
+      attributeName="opacity"
+      dur="1s"
+      values="0.2;0.5;0.9"
+      repeatCount="indefinite"
+      begin="0"/>
+    </rect>`;
+    }
+}
+/**
+ * Class to create shimmers for applications.
+ *
+ * @internal
+ */ export { ShimmerFactory as default };
+
+//# sourceMappingURL=./ShimmerFactory.js.map

package/{lib → lib-esm}/chunks/legacy-third-party-fabric-core/FabricLocalFont.js

@@ -10,8 +10,8 @@
  *
  * NOTE: Fabric.LocalFont is a modified copy of legacy Fabric that removes the
  * use of Segoe CSS font-face in favor of local fonts (Segoe/SF/Roboto).
- */
-import './fabric-core-sass/Fabric.LocalFont.global.scss';
+ */ import './fabric-core-sass/Fabric.LocalFont.global.scss';
 import './fabric-core-shim.global.scss';
 import './iconDefinitions.css';
-//# sourceMappingURL=FabricLocalFont.js.map
+
+//# sourceMappingURL=./FabricLocalFont.js.map

package/{lib → lib-esm}/common/Flights.js

@@ -1,10 +1,11 @@
 import { _SPFlight } from '@microsoft/sp-core-library';
 // cross-project flight
 export function isBotAcesFromTeamsEnabled() {
-    return _SPFlight.isEnabled(60693 /* APEXBotAceFromTeamsClient */);
+    return _SPFlight.isEnabled(60693 /* APEXBotAceFromTeamsClient */ );
 }
 // cross-project flight
 export function isServerPropertiesSanitizedEnabled() {
-    return _SPFlight.isEnabled(61389 /* APEXServerPropertiesSanitizedEnabled */);
+    return _SPFlight.isEnabled(61389 /* APEXServerPropertiesSanitizedEnabled */ );
 }
-//# sourceMappingURL=Flights.js.map
+
+//# sourceMappingURL=./Flights.js.map

package/{lib → lib-esm}/common/KillSwitches.js

@@ -1,5 +1,6 @@
 import { _SPKillSwitch } from '@microsoft/sp-core-library';
 export function isExemptWebPartWithDynamicDataFromLazyLoadKSActivated() {
-    return _SPKillSwitch.isActivated('bbd78e03-ff18-40ed-9a94-973fc659366c' /* '12/01/2022', 'Update getWebPartsExemptedFromViewPortLoading to check for containsDynamicDataSource' */);
+    return _SPKillSwitch.isActivated('bbd78e03-ff18-40ed-9a94-973fc659366c' /* '12/01/2022', 'Update getWebPartsExemptedFromViewPortLoading to check for containsDynamicDataSource' */ );
 }
-//# sourceMappingURL=KillSwitches.js.map
+
+//# sourceMappingURL=./KillSwitches.js.map

package/lib-esm/dataCollector/IWebPartLoadData.js

@@ -0,0 +1,33 @@
+/**
+ * @internal
+ */ // eslint-disable-next-line @typescript-eslint/typedef
+export const CacheStatus = {
+    True: 'true',
+    False: 'false',
+    NotAvailable: 'N/A'
+};
+/**
+ * @internal
+ */ // eslint-disable-next-line @typescript-eslint/typedef
+export const _CacheMissReason = {
+    /**
+   * Cache was available but config requested has changed.
+   */ CacheConfigMissmatch: 'CacheConfigMissmatch',
+    /**
+   * Cache did not arrvie by the time web part requested it.
+   */ LateFlush: 'LateFlush',
+    /**
+   * Cache is available but there is no cache entry for the web part.
+   */ CachedItemNotFound: 'CachedItemNotFound',
+    /**
+   * Cache is available, config is also good but is too stale for use.
+   */ CacheExpired: 'CacheExpired',
+    /**
+   * Cache miss happened but reason is not specified.
+   */ NotSpecified: 'NotSpecified',
+    /**
+   * Not Applicable if there was cache hit.
+   */ NotApplicable: 'N/A'
+};
+
+//# sourceMappingURL=./IWebPartLoadData.js.map