@atlaskit/smart-card 44.5.0 → 44.5.2

package/dist/es2019/extractors/flexible/actions/extract-rovo-chat-action.js

@@ -6,7 +6,7 @@ import { getDefinitionId, getExtensionKey, getResourceType } from '../../../stat
 import { canShowAction } from '../../../utils/actions/can-show-action';
 import { getIsRovoChatEnabled } from '../../../utils/rovo';
 import { CardAction } from '../../../view/Card/types';
-// For rovogrowth-640 post auth inline experiment
+// For rovogrowth-640 post auth inline experiment and block card experiment (NAVX-4814)
 const ELIGIBLE_EXTENSION_KEYS = new Set(['slack-object-provider', 'google-object-provider', 'onedrive-object-provider', 'github-object-provider', 'ms-teams-object-provider', 'gitlab-object-provider', 'salesforce-object-provider']);
 const extractRovoChatAction = ({
   actionOptions,
@@ -16,7 +16,7 @@ const extractRovoChatAction = ({
   response,
   rovoConfig
 }) => {
-  var _response$meta, _response$meta$suppor, _actionOptions$rovoCh;
+  var _actionOptions$rovoCh;
   if (!canShowAction(CardAction.RovoChatAction, actionOptions)) {
     return;
   }
@@ -24,12 +24,11 @@ const extractRovoChatAction = ({
   if (!isRovoChatEnabled) {
     return;
   }
-  const supportsRovoActions = response === null || response === void 0 ? void 0 : (_response$meta = response.meta) === null || _response$meta === void 0 ? void 0 : (_response$meta$suppor = _response$meta.supportedFeature) === null || _response$meta$suppor === void 0 ? void 0 : _response$meta$suppor.includes('RovoActions');
   const extensionKey = getExtensionKey(response);
   const isGoogleProvider = extensionKey === 'google-object-provider';
   const is3PAuthRovoActionEnabled = isGoogleProvider && fg('platform_sl_3p_auth_rovo_action_kill_switch');
   const is3PInlinePostAuthActionsEnabled = extensionKey !== undefined && ELIGIBLE_EXTENSION_KEYS.has(extensionKey) && fg('rovogrowth-640-inline-action-nudge-fg') && expValEqualsNoExposure('rovogrowth-640-inline-action-nudge-exp', 'isEnabled', true);
-  const is3PBlockPostAuthActionsEnabled = supportsRovoActions && fg('platform_sl_3p_auth_rovo_block_card_kill_switch');
+  const is3PBlockPostAuthActionsEnabled = extensionKey !== undefined && ELIGIBLE_EXTENSION_KEYS.has(extensionKey) && fg('platform_sl_3p_auth_rovo_block_card_kill_switch');
   const isSupportedFeature = is3PInlinePostAuthActionsEnabled || is3PAuthRovoActionEnabled || is3PBlockPostAuthActionsEnabled;
   const isOptIn = (actionOptions === null || actionOptions === void 0 ? void 0 : (_actionOptions$rovoCh = actionOptions.rovoChatAction) === null || _actionOptions$rovoCh === void 0 ? void 0 : _actionOptions$rovoCh.optIn) === true;
   const url = extractSmartLinkUrl(response);

package/dist/es2019/state/hooks/use-current-site-cloud-id/index.js

@@ -0,0 +1,28 @@
+import { useEffect, useState } from 'react';
+import { getCurrentSiteCloudId } from '../../services/current-site-cloud-id';
+export { CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY, CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY, currentSiteCloudIdService, getCurrentSiteCloudId, getCachedCurrentSiteCloudIdAndRefresh } from '../../services/current-site-cloud-id';
+const useCurrentSiteCloudId = () => {
+  const [cloudId, setCloudId] = useState(undefined);
+  const [isLoading, setIsLoading] = useState(true);
+  useEffect(() => {
+    let cancelled = false;
+    setIsLoading(true);
+    void getCurrentSiteCloudId().then(id => {
+      if (!cancelled) {
+        setCloudId(id);
+      }
+    }).finally(() => {
+      if (!cancelled) {
+        setIsLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return {
+    cloudId,
+    isLoading
+  };
+};
+export default useCurrentSiteCloudId;

package/dist/es2019/state/hooks/use-social-proof/index.js

@@ -0,0 +1,45 @@
+import { useEffect, useMemo, useState } from 'react';
+import { getProviderPctMap } from '../../services/personalization';
+const NOT_ENABLED_RESULT = {
+  connectedPct: undefined,
+  isEnabled: false,
+  isLoading: false
+};
+
+/**
+ * Fetches provider usage percentage from the TAP Delivery personalization service when the
+ * killswitch allows it. Callers decide separately (e.g. via Statsig experiment) whether to
+ * surface that data in the UI.
+ */
+const useSocialProof = (traitName, extensionKey, isKillswitchOn = false) => {
+  const isEnabled = isKillswitchOn;
+  const [providerPctMap, setProviderPctMap] = useState(undefined);
+  const [isPersonalizationLoading, setIsPersonalizationLoading] = useState(false);
+  useEffect(() => {
+    if (!isEnabled) {
+      return;
+    }
+    let cancelled = false;
+    setIsPersonalizationLoading(true);
+    getProviderPctMap(traitName).then(pctMap => {
+      if (!cancelled) {
+        setProviderPctMap(pctMap);
+        setIsPersonalizationLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [isEnabled, traitName]);
+  return useMemo(() => {
+    if (!isEnabled) {
+      return NOT_ENABLED_RESULT;
+    }
+    return {
+      connectedPct: extensionKey && providerPctMap ? providerPctMap[extensionKey] : undefined,
+      isEnabled,
+      isLoading: isPersonalizationLoading
+    };
+  }, [extensionKey, isEnabled, isPersonalizationLoading, providerPctMap]);
+};
+export default useSocialProof;

package/dist/es2019/state/services/current-site-cloud-id/index.js

@@ -0,0 +1,118 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { StorageClient } from '@atlaskit/frontend-utilities/storage-client';
+import { request } from '@atlaskit/linking-common';
+
+/**
+ * Logical key shape matches smart-card storage conventions (see personalization-service). {@link StorageClient}
+ * stores rows as `<clientKey>_<itemKey>` with `clientKey === '@atlaskit/smart-card'` and
+ * `itemKey === 'site-cloud-id:v1'` (no further scope segments; unlike `pct-map:v1:`, this is a single fixed row).
+ */
+const SMART_CARD_STORAGE_SCOPE = '@atlaskit/smart-card';
+export const CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY = 'site-cloud-id:v1';
+const smartCardStorage = new StorageClient(SMART_CARD_STORAGE_SCOPE);
+
+/** Keys written by this service in localStorage when using {@link smartCardStorage}. */
+export const CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY = `${SMART_CARD_STORAGE_SCOPE}_${CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY}`;
+export class CurrentSiteCloudIdService {
+  constructor() {
+    /**
+     * Holds the shared tenant_info work: one in-flight fetch, then (on success) a settled promise for the session cloud
+     * id so later callers never trigger another `tenant_info` in the same page lifetime (until {@link clearCache}).
+     */
+    _defineProperty(this, "tenantInfoInflightPromise", null);
+  }
+  readStoredCloudId() {
+    try {
+      const cloudId = smartCardStorage.getItem(CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY);
+      if (typeof cloudId !== 'string' || !cloudId || cloudId === 'undefined') {
+        return undefined;
+      }
+      return cloudId;
+    } catch {
+      return undefined;
+    }
+  }
+  writeStoredCloudId(cloudId) {
+    if (!cloudId) {
+      return;
+    }
+    try {
+      smartCardStorage.setItemWithExpiry(CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY, cloudId);
+    } catch {
+      // Quota, private-mode, SSR, etc. — same intent as personalization-service.
+    }
+  }
+  ensureTenantInfoInflightStarted(baseUriWithNoTrailingSlash) {
+    if (this.tenantInfoInflightPromise !== null) {
+      return;
+    }
+    this.tenantInfoInflightPromise = (async () => {
+      try {
+        const response = await request('get', baseUriWithNoTrailingSlash + '/_edge/tenant_info');
+        const cloudId = response === null || response === void 0 ? void 0 : response.cloudId;
+        if (cloudId) {
+          this.writeStoredCloudId(cloudId);
+        }
+        return cloudId ? cloudId : this.readStoredCloudId();
+      } catch {
+        this.tenantInfoInflightPromise = null;
+        return this.readStoredCloudId();
+      }
+    })();
+  }
+
+  /**
+   * Returns the currently cached cloud id synchronously and starts a background refresh.
+   * The refresh result is persisted for future calls but is not awaited by this call.
+   */
+  getCachedCloudIdAndRefresh() {
+    this.ensureTenantInfoInflightStarted('');
+    return this.readStoredCloudId();
+  }
+
+  /** Writes tenant cloud id for tests or callers that intentionally warm storage before edge resolves. */
+  persistStoredCloudId(cloudId) {
+    this.writeStoredCloudId(cloudId);
+  }
+
+  /**
+   * When local storage already has a tenant cloud id, it is returned immediately; a background tenant_info refresh
+   * is still kicked off unless one is already in flight.
+   *
+   * Without storage, this awaits the deduped in-flight tenant_info (first concurrent caller chooses the URL;
+   * all share one promise regardless of subsequent `baseUriWithNoTrailingSlash`).
+   *
+   * On network success with no cloud id, or on failure: falls back via {@link readStoredCloudId}.
+   */
+  async get(baseUriWithNoTrailingSlash = '') {
+    const fromStorage = this.readStoredCloudId();
+    this.ensureTenantInfoInflightStarted(baseUriWithNoTrailingSlash);
+    if (fromStorage) {
+      return fromStorage;
+    }
+    return this.tenantInfoInflightPromise;
+  }
+
+  /** Clears the session pin so the next {@link get} may run `tenant_info` again (e.g. tests). */
+  clearCache() {
+    this.tenantInfoInflightPromise = null;
+  }
+}
+export const currentSiteCloudIdService = new CurrentSiteCloudIdService();
+
+/**
+ * Resolves the current site cloud id through the module-level {@link currentSiteCloudIdService}.
+ * Returns a stored cloud id immediately when one exists; otherwise waits for the shared
+ * `tenant_info` request and persists the result for subsequent cached reads.
+ */
+export const getCurrentSiteCloudId = (baseUriWithNoTrailingSlash = '') => currentSiteCloudIdService.get(baseUriWithNoTrailingSlash);
+
+/**
+ * Reads the current site cloud id from browser storage (the `site-cloud-id:v1` row) via the
+ * module-level {@link currentSiteCloudIdService} singleton, without awaiting network work.
+ * Calling this also starts the shared `tenant_info` refresh in the background when one is not
+ * already running, so a later call can observe a refreshed value when available.
+ */
+export function getCachedCurrentSiteCloudIdAndRefresh() {
+  return currentSiteCloudIdService.getCachedCloudIdAndRefresh();
+}

package/dist/es2019/state/services/personalization/index.js

@@ -0,0 +1,164 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { StorageClient } from '@atlaskit/frontend-utilities/storage-client';
+import { getCurrentSiteCloudId, getCachedCurrentSiteCloudIdAndRefresh } from '../current-site-cloud-id';
+const BASE_URL = '/gateway/api/tap-delivery/api/v3/personalization';
+
+/**
+ * Logical key shape: `@atlaskit/smart-card:<feature>:<schema-version>:<scope>` (see smart-card
+ * storage conventions). {@link StorageClient} narrows the localStorage key to
+ * `<clientKey>_<itemKey>` with `clientKey === '@atlaskit/smart-card'` and
+ * `itemKey === 'pct-map:v1:<cloudId>:<traitName>'` (scope segments URI-encoded).
+ */
+export const PERSONALIZATION_STORAGE_SCOPE = '@atlaskit/smart-card';
+export const PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX = 'pct-map:v1:';
+const smartCardStorage = new StorageClient(PERSONALIZATION_STORAGE_SCOPE);
+
+/** Keys written by this service in localStorage when using {@link smartCardStorage}. */
+const LOCAL_STORAGE_ROW_KEY_PREFIX = `${PERSONALIZATION_STORAGE_SCOPE}_${PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX}`;
+function pctMapStorageItemKey(cloudId, traitName) {
+  return `${PERSONALIZATION_STORAGE_ITEM_KEY_PREFIX}${encodeURIComponent(cloudId)}:${encodeURIComponent(traitName)}`;
+}
+async function fetchSiteTraits(cloudId) {
+  var _data$attributes;
+  const response = await fetch(`${BASE_URL}/site/${cloudId}`, {
+    method: 'GET',
+    credentials: 'include',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  });
+  if (!response.ok) {
+    return [];
+  }
+  const data = await response.json();
+  return (_data$attributes = data === null || data === void 0 ? void 0 : data.attributes) !== null && _data$attributes !== void 0 ? _data$attributes : [];
+}
+
+/**
+ * Service for fetching site-level traits from the TAP Delivery personalization API.
+ */
+export class PersonalizationService {
+  constructor() {
+    _defineProperty(this, "cache", new Map());
+  }
+  /**
+   * Returns the currently cached provider percentage map synchronously and starts a background refresh.
+   * The refresh result is persisted for future calls but is not awaited by this call.
+   */
+  getCachedProviderPctMapAndRefresh(traitName) {
+    const cloudId = getCachedCurrentSiteCloudIdAndRefresh();
+    const fromStorage = cloudId && this.readStoredProviderPctMap(cloudId, traitName) || null;
+    void this.getProviderPctMap(traitName);
+    return fromStorage;
+  }
+  async getProviderPctMap(traitName) {
+    const cachedPromise = this.cache.get(traitName);
+    if (cachedPromise) {
+      return cachedPromise;
+    }
+    const promise = (async () => {
+      try {
+        const cloudId = await getCurrentSiteCloudId();
+        if (!cloudId) {
+          return undefined;
+        }
+        const traits = await fetchSiteTraits(cloudId);
+        const trait = traits.find(t => t.name === traitName);
+        const mapped = this.parseTraitValue(trait === null || trait === void 0 ? void 0 : trait.value);
+        if (mapped !== undefined) {
+          this.writeStoredProviderPctMap(cloudId, traitName, mapped);
+        }
+        return mapped;
+      } catch {
+        return undefined;
+      }
+    })();
+    this.cache.set(traitName, promise);
+    return promise;
+  }
+  readStoredProviderPctMap(cloudId, traitName) {
+    try {
+      const stored = smartCardStorage.getItem(pctMapStorageItemKey(cloudId, traitName));
+      if (stored === undefined || stored === null) {
+        return null;
+      }
+      return this.normalizeProviderPctMap(stored);
+    } catch {
+      return null;
+    }
+  }
+  writeStoredProviderPctMap(cloudId, traitName, map) {
+    try {
+      smartCardStorage.setItemWithExpiry(pctMapStorageItemKey(cloudId, traitName), map);
+    } catch {
+      // Quota, private-mode, etc.
+    }
+  }
+  normalizeProviderPctMap(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return null;
+    }
+    const map = {};
+    const entries = Object.entries(value);
+    for (const [providerKey, percentageRaw] of entries) {
+      if (typeof percentageRaw !== 'number' || !Number.isFinite(percentageRaw)) {
+        return null;
+      }
+      map[providerKey] = percentageRaw;
+    }
+    return map;
+  }
+  parseTraitValue(raw) {
+    if (typeof raw !== 'string') {
+      return undefined;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      const normalized = this.normalizeProviderPctMap(parsed);
+      return normalized === null ? undefined : normalized;
+    } catch {
+      return undefined;
+    }
+  }
+  clearCache() {
+    this.cache.clear();
+    this.clearStoredProviderPctMaps();
+  }
+  clearStoredProviderPctMaps() {
+    if (typeof globalThis.localStorage === 'undefined' || globalThis.localStorage === null) {
+      return;
+    }
+    const keysToRemove = [];
+    for (let index = 0; index < globalThis.localStorage.length; index += 1) {
+      const key = globalThis.localStorage.key(index);
+      if (key !== null && key.startsWith(LOCAL_STORAGE_ROW_KEY_PREFIX)) {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      try {
+        globalThis.localStorage.removeItem(key);
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+}
+export const personalizationService = new PersonalizationService();
+
+/**
+ * Resolves the provider percentage map for a TAP Delivery trait through the module-level
+ * {@link personalizationService}. Work is deduped per trait name for the page lifetime, and a
+ * successful response is persisted by cloud id and trait name for later cached reads.
+ */
+export const getProviderPctMap = traitName => personalizationService.getProviderPctMap(traitName);
+
+/**
+ * Reads the provider percentage map for a trait from browser storage via the module-level
+ * {@link personalizationService} singleton, without awaiting network work.
+ * Calling this also starts the trait-scoped shared refresh in the background, so a later call can
+ * use a refreshed value when it becomes available.
+ */
+export function getCachedProviderPctMapAndRefresh(traitName) {
+  return personalizationService.getCachedProviderPctMapAndRefresh(traitName);
+}

package/dist/es2019/utils/analytics/analytics.js

@@ -2,7 +2,7 @@ export const ANALYTICS_CHANNEL = 'media';
 export const context = {
   componentName: 'smart-cards',
   packageName: "@atlaskit/smart-card" || '',
-  packageVersion: "44.4.0" || ''
+  packageVersion: "44.5.1" || ''
 };
 export let TrackQuickActionType = /*#__PURE__*/function (TrackQuickActionType) {
   TrackQuickActionType["StatusUpdate"] = "StatusUpdate";

package/dist/es2019/view/LinkUrl/index.js

@@ -12,7 +12,7 @@ import LinkWarningModal from './LinkWarningModal';
 import { useLinkWarningModal } from './LinkWarningModal/hooks/use-link-warning-modal';
 const PACKAGE_DATA = {
   packageName: "@atlaskit/smart-card",
-  packageVersion: "44.4.0",
+  packageVersion: "44.5.1",
   componentName: 'linkUrl'
 };
 const Anchor = withLinkClickedEvent('a');

package/dist/esm/extractors/flexible/actions/extract-rovo-chat-action.js

@@ -6,10 +6,10 @@ import { getDefinitionId, getExtensionKey, getResourceType } from '../../../stat
 import { canShowAction } from '../../../utils/actions/can-show-action';
 import { getIsRovoChatEnabled } from '../../../utils/rovo';
 import { CardAction } from '../../../view/Card/types';
-// For rovogrowth-640 post auth inline experiment
+// For rovogrowth-640 post auth inline experiment and block card experiment (NAVX-4814)
 var ELIGIBLE_EXTENSION_KEYS = new Set(['slack-object-provider', 'google-object-provider', 'onedrive-object-provider', 'github-object-provider', 'ms-teams-object-provider', 'gitlab-object-provider', 'salesforce-object-provider']);
 var extractRovoChatAction = function extractRovoChatAction(_ref) {
-  var _response$meta, _actionOptions$rovoCh;
+  var _actionOptions$rovoCh;
   var actionOptions = _ref.actionOptions,
     appearance = _ref.appearance,
     id = _ref.id,
@@ -23,12 +23,11 @@ var extractRovoChatAction = function extractRovoChatAction(_ref) {
   if (!isRovoChatEnabled) {
     return;
   }
-  var supportsRovoActions = response === null || response === void 0 || (_response$meta = response.meta) === null || _response$meta === void 0 || (_response$meta = _response$meta.supportedFeature) === null || _response$meta === void 0 ? void 0 : _response$meta.includes('RovoActions');
   var extensionKey = getExtensionKey(response);
   var isGoogleProvider = extensionKey === 'google-object-provider';
   var is3PAuthRovoActionEnabled = isGoogleProvider && fg('platform_sl_3p_auth_rovo_action_kill_switch');
   var is3PInlinePostAuthActionsEnabled = extensionKey !== undefined && ELIGIBLE_EXTENSION_KEYS.has(extensionKey) && fg('rovogrowth-640-inline-action-nudge-fg') && expValEqualsNoExposure('rovogrowth-640-inline-action-nudge-exp', 'isEnabled', true);
-  var is3PBlockPostAuthActionsEnabled = supportsRovoActions && fg('platform_sl_3p_auth_rovo_block_card_kill_switch');
+  var is3PBlockPostAuthActionsEnabled = extensionKey !== undefined && ELIGIBLE_EXTENSION_KEYS.has(extensionKey) && fg('platform_sl_3p_auth_rovo_block_card_kill_switch');
   var isSupportedFeature = is3PInlinePostAuthActionsEnabled || is3PAuthRovoActionEnabled || is3PBlockPostAuthActionsEnabled;
   var isOptIn = (actionOptions === null || actionOptions === void 0 || (_actionOptions$rovoCh = actionOptions.rovoChatAction) === null || _actionOptions$rovoCh === void 0 ? void 0 : _actionOptions$rovoCh.optIn) === true;
   var url = extractSmartLinkUrl(response);

package/dist/esm/state/hooks/use-current-site-cloud-id/index.js

@@ -0,0 +1,35 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useEffect, useState } from 'react';
+import { getCurrentSiteCloudId } from '../../services/current-site-cloud-id';
+export { CURRENT_SITE_CLOUD_ID_LOCAL_STORAGE_KEY, CURRENT_SITE_CLOUD_ID_STORAGE_ITEM_KEY, currentSiteCloudIdService, getCurrentSiteCloudId, getCachedCurrentSiteCloudIdAndRefresh } from '../../services/current-site-cloud-id';
+var useCurrentSiteCloudId = function useCurrentSiteCloudId() {
+  var _useState = useState(undefined),
+    _useState2 = _slicedToArray(_useState, 2),
+    cloudId = _useState2[0],
+    setCloudId = _useState2[1];
+  var _useState3 = useState(true),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isLoading = _useState4[0],
+    setIsLoading = _useState4[1];
+  useEffect(function () {
+    var cancelled = false;
+    setIsLoading(true);
+    void getCurrentSiteCloudId().then(function (id) {
+      if (!cancelled) {
+        setCloudId(id);
+      }
+    }).finally(function () {
+      if (!cancelled) {
+        setIsLoading(false);
+      }
+    });
+    return function () {
+      cancelled = true;
+    };
+  }, []);
+  return {
+    cloudId: cloudId,
+    isLoading: isLoading
+  };
+};
+export default useCurrentSiteCloudId;

package/dist/esm/state/hooks/use-social-proof/index.js

@@ -0,0 +1,53 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useEffect, useMemo, useState } from 'react';
+import { getProviderPctMap } from '../../services/personalization';
+var NOT_ENABLED_RESULT = {
+  connectedPct: undefined,
+  isEnabled: false,
+  isLoading: false
+};
+
+/**
+ * Fetches provider usage percentage from the TAP Delivery personalization service when the
+ * killswitch allows it. Callers decide separately (e.g. via Statsig experiment) whether to
+ * surface that data in the UI.
+ */
+var useSocialProof = function useSocialProof(traitName, extensionKey) {
+  var isKillswitchOn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var isEnabled = isKillswitchOn;
+  var _useState = useState(undefined),
+    _useState2 = _slicedToArray(_useState, 2),
+    providerPctMap = _useState2[0],
+    setProviderPctMap = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isPersonalizationLoading = _useState4[0],
+    setIsPersonalizationLoading = _useState4[1];
+  useEffect(function () {
+    if (!isEnabled) {
+      return;
+    }
+    var cancelled = false;
+    setIsPersonalizationLoading(true);
+    getProviderPctMap(traitName).then(function (pctMap) {
+      if (!cancelled) {
+        setProviderPctMap(pctMap);
+        setIsPersonalizationLoading(false);
+      }
+    });
+    return function () {
+      cancelled = true;
+    };
+  }, [isEnabled, traitName]);
+  return useMemo(function () {
+    if (!isEnabled) {
+      return NOT_ENABLED_RESULT;
+    }
+    return {
+      connectedPct: extensionKey && providerPctMap ? providerPctMap[extensionKey] : undefined,
+      isEnabled: isEnabled,
+      isLoading: isPersonalizationLoading
+    };
+  }, [extensionKey, isEnabled, isPersonalizationLoading, providerPctMap]);
+};
+export default useSocialProof;