@atlaskit/smart-card 45.20.7 → 45.21.0

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

@@ -1,151 +1 @@
-import React from 'react';
-import { browser } from '@atlaskit/linking-common/user-agent';
-import { useLinkClicked, useMouseDownEvent } from '../../state/analytics/useLinkClicked';
-import { ANALYTICS_CHANNEL } from './analytics';
-export const buttonMap = new Map([[undefined, 'none'], [0, 'left'], [1, 'middle'], [2, 'right']]);
-export const getKeys = e => {
-  return ['alt', 'ctrl', 'meta', 'shift'].filter(key => e[`${key}Key`] === true);
-};
-const isContentEditable = el => {
-  return el instanceof HTMLElement && el.isContentEditable;
-};
-export function getLinkClickOutcome(e, clickType) {
-  const {
-    mac,
-    safari
-  } = browser();
-
-  /**
-   * If the link/parent is content editable then left click won't have typical effect
-   */
-  if (isContentEditable(e.currentTarget) && ['left', 'middle'].includes(clickType)) {
-    return 'contentEditable';
-  }
-  switch (clickType) {
-    case 'left':
-    case 'keyboard':
-      {
-        // Meta key = Cmd for macOS, Windows key sometimes for Windows (otherwise false)
-        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/metaKey
-        if (e.metaKey) {
-          return mac ? 'clickThroughNewTabOrWindow' : 'clickThrough';
-        }
-        if (e.shiftKey) {
-          // Alt/option click in safari typically adds the link to bookmarks
-          if (safari) {
-            return 'alt';
-          }
-          return 'clickThroughNewTabOrWindow';
-        }
-        if (e.ctrlKey) {
-          // Ctrl+Left on macOS defaults to triggering a right click instead (so won't trigger onClick)
-          // but if this behaviour is disabled, likely outcome is clickThrough
-          if (mac) {
-            return 'clickThrough';
-          }
-          return 'clickThroughNewTabOrWindow';
-        }
-        if (e.altKey) {
-          return 'alt';
-        }
-        const target = e.currentTarget.getAttribute('target');
-        if (target === '_blank') {
-          return 'clickThroughNewTabOrWindow';
-        }
-        return 'clickThrough';
-      }
-    case 'middle':
-      {
-        return 'clickThroughNewTabOrWindow';
-      }
-    case 'right':
-      {
-        return 'contextMenu';
-      }
-  }
-  return 'unknown';
-}
-const linkClickedEvent = ({
-  clickType,
-  clickOutcome,
-  keysHeld,
-  defaultPrevented
-}) => ({
-  action: 'clicked',
-  actionSubject: 'link',
-  eventType: 'ui',
-  attributes: {
-    clickType,
-    clickOutcome,
-    keysHeld,
-    defaultPrevented
-  }
-});
-export const createLinkClickedPayload = event => {
-  // Through the `detail` property, we're able to determine if the event is (most likely) triggered via keyboard
-  // https://developer.mozilla.org/en-US/docs/Web/API/UIEvent/detail
-  const isKeyboard = event.nativeEvent.detail === 0;
-  const clickType = isKeyboard ? 'keyboard' : buttonMap.get(event.button);
-  if (!clickType) {
-    return;
-  }
-  const clickOutcome = getLinkClickOutcome(event, clickType);
-  const keysHeld = getKeys(event);
-  const defaultPrevented = event.defaultPrevented;
-  const linkClickedEventResult = linkClickedEvent({
-    clickType,
-    clickOutcome,
-    keysHeld,
-    defaultPrevented
-  });
-
-  // if the current target is an anchor tag, we can get the href from it and use that as the url being navigated too.
-  if (event.currentTarget instanceof HTMLAnchorElement) {
-    const url = event.currentTarget.href;
-    return {
-      ...linkClickedEventResult,
-      nonPrivacySafeAttributes: {
-        url
-      }
-    };
-  } else {
-    // We can't get the href from the event target, so dont include the url or any non privacy safe attributes
-    return linkClickedEventResult;
-  }
-};
-export const fireLinkClickedEvent = createAnalyticsEvent => (event, overrides = {}) => {
-  const payload = createLinkClickedPayload(event);
-  if (payload) {
-    createAnalyticsEvent({
-      ...payload,
-      ...overrides,
-      attributes: {
-        ...payload.attributes,
-        ...(overrides === null || overrides === void 0 ? void 0 : overrides.attributes)
-      },
-      nonPrivacySafeAttributes: {
-        ...payload.nonPrivacySafeAttributes,
-        ...(overrides === null || overrides === void 0 ? void 0 : overrides.nonPrivacySafeAttributes)
-      }
-    }).fire(ANALYTICS_CHANNEL);
-  }
-};
-const getDisplayName = WrappedComponent => {
-  if (typeof WrappedComponent === 'string') {
-    return WrappedComponent;
-  }
-  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
-};
-export function withLinkClickedEvent(WrappedComponent) {
-  const Component = props => {
-    const onClick = useLinkClicked(props.onClick);
-    const onMouseDown = useMouseDownEvent(props.onMouseDown);
-    return /*#__PURE__*/React.createElement(WrappedComponent, {
-      ...props,
-      onClick,
-      onMouseDown
-    });
-  };
-  Component.displayName = `withLinkClickedEvent(${getDisplayName(WrappedComponent)})`;
-  return Component;
-}
+export const buttonMap = new Map([[undefined, 'none'], [0, 'left'], [1, 'middle'], [2, 'right']]);

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

@@ -0,0 +1,51 @@
+import { buttonMap } from './click';
+import { getKeys } from './getKeys';
+import { getLinkClickOutcome } from './getLinkClickOutcome';
+const linkClickedEvent = ({
+  clickType,
+  clickOutcome,
+  keysHeld,
+  defaultPrevented
+}) => ({
+  action: 'clicked',
+  actionSubject: 'link',
+  eventType: 'ui',
+  attributes: {
+    clickType,
+    clickOutcome,
+    keysHeld,
+    defaultPrevented
+  }
+});
+export const createLinkClickedPayload = event => {
+  // Through the `detail` property, we're able to determine if the event is (most likely) triggered via keyboard
+  // https://developer.mozilla.org/en-US/docs/Web/API/UIEvent/detail
+  const isKeyboard = event.nativeEvent.detail === 0;
+  const clickType = isKeyboard ? 'keyboard' : buttonMap.get(event.button);
+  if (!clickType) {
+    return;
+  }
+  const clickOutcome = getLinkClickOutcome(event, clickType);
+  const keysHeld = getKeys(event);
+  const defaultPrevented = event.defaultPrevented;
+  const linkClickedEventResult = linkClickedEvent({
+    clickType,
+    clickOutcome,
+    keysHeld,
+    defaultPrevented
+  });
+
+  // if the current target is an anchor tag, we can get the href from it and use that as the url being navigated too.
+  if (event.currentTarget instanceof HTMLAnchorElement) {
+    const url = event.currentTarget.href;
+    return {
+      ...linkClickedEventResult,
+      nonPrivacySafeAttributes: {
+        url
+      }
+    };
+  } else {
+    // We can't get the href from the event target, so dont include the url or any non privacy safe attributes
+    return linkClickedEventResult;
+  }
+};

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

@@ -0,0 +1,19 @@
+import { ANALYTICS_CHANNEL } from './analytics';
+import { createLinkClickedPayload } from './createLinkClickedPayload';
+export const fireLinkClickedEvent = createAnalyticsEvent => (event, overrides = {}) => {
+  const payload = createLinkClickedPayload(event);
+  if (payload) {
+    createAnalyticsEvent({
+      ...payload,
+      ...overrides,
+      attributes: {
+        ...payload.attributes,
+        ...(overrides === null || overrides === void 0 ? void 0 : overrides.attributes)
+      },
+      nonPrivacySafeAttributes: {
+        ...payload.nonPrivacySafeAttributes,
+        ...(overrides === null || overrides === void 0 ? void 0 : overrides.nonPrivacySafeAttributes)
+      }
+    }).fire(ANALYTICS_CHANNEL);
+  }
+};

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

@@ -0,0 +1,6 @@
+import { ANALYTICS_CHANNEL } from './analytics';
+export const fireSmartLinkEvent = (payload, createAnalyticsEvent) => {
+  if (createAnalyticsEvent) {
+    createAnalyticsEvent(payload).fire(ANALYTICS_CHANNEL);
+  }
+};

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

@@ -0,0 +1,3 @@
+export const getKeys = e => {
+  return ['alt', 'ctrl', 'meta', 'shift'].filter(key => e[`${key}Key`] === true);
+};

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

@@ -0,0 +1,60 @@
+import { browser } from '@atlaskit/linking-common/user-agent';
+const isContentEditable = el => {
+  return el instanceof HTMLElement && el.isContentEditable;
+};
+export function getLinkClickOutcome(e, clickType) {
+  const {
+    mac,
+    safari
+  } = browser();
+
+  /**
+   * If the link/parent is content editable then left click won't have typical effect
+   */
+  if (isContentEditable(e.currentTarget) && ['left', 'middle'].includes(clickType)) {
+    return 'contentEditable';
+  }
+  switch (clickType) {
+    case 'left':
+    case 'keyboard':
+      {
+        // Meta key = Cmd for macOS, Windows key sometimes for Windows (otherwise false)
+        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/metaKey
+        if (e.metaKey) {
+          return mac ? 'clickThroughNewTabOrWindow' : 'clickThrough';
+        }
+        if (e.shiftKey) {
+          // Alt/option click in safari typically adds the link to bookmarks
+          if (safari) {
+            return 'alt';
+          }
+          return 'clickThroughNewTabOrWindow';
+        }
+        if (e.ctrlKey) {
+          // Ctrl+Left on macOS defaults to triggering a right click instead (so won't trigger onClick)
+          // but if this behaviour is disabled, likely outcome is clickThrough
+          if (mac) {
+            return 'clickThrough';
+          }
+          return 'clickThroughNewTabOrWindow';
+        }
+        if (e.altKey) {
+          return 'alt';
+        }
+        const target = e.currentTarget.getAttribute('target');
+        if (target === '_blank') {
+          return 'clickThroughNewTabOrWindow';
+        }
+        return 'clickThrough';
+      }
+    case 'middle':
+      {
+        return 'clickThroughNewTabOrWindow';
+      }
+    case 'right':
+      {
+        return 'contextMenu';
+      }
+  }
+  return 'unknown';
+}

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

@@ -0,0 +1,33 @@
+import { getResolvedAttributes } from '@atlaskit/link-analytics/resolved-attributes';
+import { context } from './analytics';
+const getExtendedResolvedAttributes = (linkDetails, details, linkStatus, error) => {
+  var _details$meta$definit, _details$meta, _details$meta$resourc, _details$meta2;
+  return {
+    definitionId: (_details$meta$definit = details === null || details === void 0 ? void 0 : (_details$meta = details.meta) === null || _details$meta === void 0 ? void 0 : _details$meta.definitionId) !== null && _details$meta$definit !== void 0 ? _details$meta$definit : null,
+    resourceType: (_details$meta$resourc = details === null || details === void 0 ? void 0 : (_details$meta2 = details.meta) === null || _details$meta2 === void 0 ? void 0 : _details$meta2.resourceType) !== null && _details$meta$resourc !== void 0 ? _details$meta$resourc : null,
+    ...getResolvedAttributes(linkDetails, details, linkStatus, error)
+  };
+};
+export const getSmartLinkAnalyticsContext = ({
+  display,
+  id,
+  response,
+  source,
+  status,
+  url,
+  error
+}) => {
+  const resolvedAttributes = getExtendedResolvedAttributes({
+    url,
+    displayCategory: display === 'url' ? 'link' : 'smartLink'
+  }, response, status, error);
+  return {
+    source,
+    attributes: {
+      ...context,
+      display,
+      id,
+      ...resolvedAttributes
+    }
+  };
+};

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

@@ -0,0 +1,32 @@
+import { useMemo } from 'react';
+import { useSmartLinkContext } from '@atlaskit/link-provider';
+import { getUrl } from '@atlaskit/linking-common';
+import { getSmartLinkAnalyticsContext } from './getSmartLinkAnalyticsContext';
+
+/**
+ * Provides an analytics context data to supply attributes to events based on a URL
+ * and the link state in the store
+ * @deprecated Use useSmartLinkAnalyticsUtils instead
+ */
+export const useSmartLinkAnalyticsContext = ({
+  display,
+  id,
+  source,
+  url
+}) => {
+  const {
+    store
+  } = useSmartLinkContext();
+  const state = store ? getUrl(store, url) : undefined;
+  return useMemo(() => {
+    return getSmartLinkAnalyticsContext({
+      display,
+      id,
+      response: state === null || state === void 0 ? void 0 : state.details,
+      source,
+      status: state === null || state === void 0 ? void 0 : state.status,
+      url,
+      error: state === null || state === void 0 ? void 0 : state.error
+    });
+  }, [display, id, source, state === null || state === void 0 ? void 0 : state.details, state === null || state === void 0 ? void 0 : state.status, url, state === null || state === void 0 ? void 0 : state.error]);
+};

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

@@ -0,0 +1,28 @@
+import { useCallback, useMemo } from 'react';
+import { useSmartLinkContext } from '@atlaskit/link-provider';
+import { getUrl } from '@atlaskit/linking-common';
+import { getSmartLinkAnalyticsContext } from './getSmartLinkAnalyticsContext';
+/**
+ * Provides an analytics context data to supply attributes to events based on a URL
+ * and the link state in the store
+ */
+export const useSmartLinkAnalyticsUtils = () => {
+  const {
+    store
+  } = useSmartLinkContext();
+  const getByUrl = useCallback((url, props) => {
+    const state = store ? getUrl(store, url) : undefined;
+    return getSmartLinkAnalyticsContext({
+      display: props === null || props === void 0 ? void 0 : props.display,
+      id: props === null || props === void 0 ? void 0 : props.id,
+      response: state === null || state === void 0 ? void 0 : state.details,
+      source: props === null || props === void 0 ? void 0 : props.source,
+      status: state === null || state === void 0 ? void 0 : state.status,
+      url,
+      error: state === null || state === void 0 ? void 0 : state.error
+    });
+  }, [store]);
+  return useMemo(() => ({
+    getByUrl
+  }), [getByUrl]);
+};

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

@@ -0,0 +1,22 @@
+import React from 'react';
+import { useLinkClicked } from '../../state/analytics/useLinkClicked';
+import { useMouseDownEvent } from '../../state/analytics/useMouseDownEvent';
+const getDisplayName = WrappedComponent => {
+  if (typeof WrappedComponent === 'string') {
+    return WrappedComponent;
+  }
+  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
+};
+export function withLinkClickedEvent(WrappedComponent) {
+  const Component = props => {
+    const onClick = useLinkClicked(props.onClick);
+    const onMouseDown = useMouseDownEvent(props.onMouseDown);
+    return /*#__PURE__*/React.createElement(WrappedComponent, {
+      ...props,
+      onClick,
+      onMouseDown
+    });
+  };
+  Component.displayName = `withLinkClickedEvent(${getDisplayName(WrappedComponent)})`;
+  return Component;
+}

package/dist/es2019/utils/clear-marks.js

@@ -0,0 +1,7 @@
+import { hasPerformanceAPIAvailable } from './has-performance-api-available';
+export const clearMarks = id => {
+  if (hasPerformanceAPIAvailable) {
+    const marks = performance.getEntriesByType('mark').filter(mark => mark.name.includes(id));
+    marks.forEach(mark => performance.clearMarks(mark.name));
+  }
+};

package/dist/es2019/utils/clear-measures.js

@@ -0,0 +1,7 @@
+import { hasPerformanceAPIAvailable } from './has-performance-api-available';
+export const clearMeasures = id => {
+  if (hasPerformanceAPIAvailable) {
+    const measures = performance.getEntriesByType('measure').filter(measure => measure.name.includes(id));
+    measures.forEach(measure => performance.clearMeasures(measure.name));
+  }
+};

package/dist/es2019/utils/create.js

@@ -0,0 +1,27 @@
+import { getMarkName } from './get-mark-name';
+import { getMeasure } from './get-measure';
+import { getMeasureName } from './get-measure-name';
+import { hasPerformanceAPIAvailable } from './has-performance-api-available';
+const getMark = (id, status) => {
+  if (hasPerformanceAPIAvailable) {
+    const name = getMarkName(id, status);
+    const marks = performance.getEntriesByName(name);
+    if (marks.length > 0) {
+      return marks[0];
+    }
+    return undefined;
+  }
+};
+export const create = (id, status) => {
+  if (hasPerformanceAPIAvailable) {
+    const name = getMeasureName(id, status);
+    const measure = getMeasure(id, status);
+    if (!measure) {
+      const startMark = getMark(id, 'pending');
+      const endMark = getMark(id, status);
+      if (startMark && endMark) {
+        performance.measure(name, startMark.name, endMark.name);
+      }
+    }
+  }
+};

package/dist/es2019/utils/download-url.js

@@ -0,0 +1,23 @@
+export const downloadUrl = async url => {
+  if (!url) {
+    return;
+  }
+  const isIE11 = !!window.MSInputMethodContext && !!document.documentMode;
+  const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  const iframeName = 'media-download-iframe';
+  const link = document.createElement('a');
+  let iframe = document.getElementById(iframeName);
+  if (!iframe) {
+    iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    iframe.id = iframeName;
+    iframe.name = iframeName;
+    document.body.appendChild(iframe);
+  }
+  link.href = url;
+  link.download = url;
+  link.target = isIE11 || isSafari ? '_blank' : iframeName;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+};

package/dist/es2019/utils/fake-factory.js

@@ -0,0 +1,15 @@
+import { CardClient } from '@atlaskit/link-provider';
+export const fakeFactory = (implementation, implementationPost, implementationPrefetch, implementationAri) => class CustomClient extends CardClient {
+  async fetchData(url) {
+    return await implementation(url);
+  }
+  async postData() {
+    return await implementationPost();
+  }
+  async prefetchData() {
+    return await implementationPrefetch();
+  }
+  async fetchDataAris(aris) {
+    return await implementationAri(aris);
+  }
+};

package/dist/es2019/utils/fake-response.js

@@ -0,0 +1,2 @@
+import { mocks } from './mocks';
+export const fakeResponse = () => Promise.resolve(mocks.success);

package/dist/es2019/utils/get-ai-summary-error-message.js

@@ -0,0 +1,24 @@
+import { CONTENT_URL_ACCEPTABLE_USE_POLICY, CONTENT_URL_AI_TROUBLESHOOTING } from '../constants';
+import { messages } from '../messages';
+export const getAISummaryErrorMessage = error => {
+  switch (error) {
+    case 'ACCEPTABLE_USE_VIOLATIONS':
+      return {
+        message: messages.ai_summary_error_acceptable_use_violation,
+        url: CONTENT_URL_ACCEPTABLE_USE_POLICY
+      };
+    case 'HIPAA_CONTENT_DETECTED':
+      return {
+        message: messages.ai_summary_error_hipaa_content_detected
+      };
+    case 'EXCEEDING_CONTEXT_LENGTH_ERROR':
+      return {
+        message: messages.ai_summary_error_exceeding_context_length_error
+      };
+    default:
+      return {
+        message: messages.ai_summary_error_generic_rebrand,
+        url: CONTENT_URL_AI_TROUBLESHOOTING
+      };
+  }
+};

package/dist/es2019/utils/get-anchor-attributes-from-event.js

@@ -0,0 +1,28 @@
+/**
+ * Extracts `href` and `target` from the anchor element that is the event's `currentTarget`.
+ *
+ * Smart Link click handlers are attached to multiple card renderers (InlineCard, BlockCard,
+ * EmbedCard, FlexibleCard). When the handler needs to manually open a link — for example,
+ * when native anchor navigation has been prevented — it uses this helper to read the
+ * anchor's resolved URL and intended target from the event rather than re-deriving them.
+ *
+ * Returns `{ href: undefined, target: '_self' }` when `currentTarget` is not an anchor
+ * element (e.g. a button or wrapper div), so callers can safely fall back to a default target.
+ *
+ * @param event - A React mouse or keyboard event whose `currentTarget` may be an anchor.
+ * @returns The resolved absolute `href` and `target` attribute of the anchor, or safe
+ *   defaults if `currentTarget` is not an anchor.
+ */
+export const getAnchorAttributesFromEvent = event => {
+  const currentTarget = event.currentTarget;
+  if (!(currentTarget instanceof HTMLAnchorElement)) {
+    return {
+      href: undefined,
+      target: '_self'
+    };
+  }
+  return {
+    href: currentTarget.href,
+    target: currentTarget.target || '_self'
+  };
+};

package/dist/es2019/utils/get-empty-json-ld.js

@@ -0,0 +1,2 @@
+import { emptyData } from './jsonld';
+export const getEmptyJsonLd = () => emptyData;

package/dist/es2019/utils/get-forbidden-json-ld.js

@@ -0,0 +1,12 @@
+import { emptyData } from './jsonld';
+export const getForbiddenJsonLd = () => ({
+  meta: {
+    visibility: 'restricted',
+    access: 'forbidden',
+    auth: [],
+    definitionId: 'provider-not-found'
+  },
+  data: {
+    ...emptyData
+  }
+});

package/dist/es2019/utils/get-icon-for-file-type.js

@@ -0,0 +1,49 @@
+import React from 'react';
+import Loadable from 'react-loadable';
+import { fg } from '@atlaskit/platform-feature-flags/fg';
+import extractFileFormatIcon from '../extractors/flexible/icon/extract-file-formatIcon';
+import { getLazyIcons } from './get-lazy-icons';
+const getTypeToIconMap = fileFormat => {
+  const iconDescriptor = extractFileFormatIcon(fileFormat);
+  if (!(iconDescriptor !== null && iconDescriptor !== void 0 && iconDescriptor.icon)) {
+    return null;
+  }
+  const lazyIcons = getLazyIcons();
+  if (fg('platform_navx_smart_link_icon_label_a11y')) {
+    var _lazyIcons$iconDescri, _iconDescriptor$label;
+    return [(_lazyIcons$iconDescri = lazyIcons[iconDescriptor.icon]) === null || _lazyIcons$iconDescri === void 0 ? void 0 : _lazyIcons$iconDescri.default, (_iconDescriptor$label = iconDescriptor.label) !== null && _iconDescriptor$label !== void 0 ? _iconDescriptor$label : ''];
+  } else {
+    var _lazyIcons$iconDescri2;
+    return [(_lazyIcons$iconDescri2 = lazyIcons[iconDescriptor.icon]) === null || _lazyIcons$iconDescri2 === void 0 ? void 0 : _lazyIcons$iconDescri2.default];
+  }
+};
+export const getIconForFileType = (fileMimeType, showIconLabel) => {
+  if (!fileMimeType) {
+    return;
+  }
+  let icon = getTypeToIconMap(fileMimeType.toLowerCase());
+  if (!icon) {
+    return;
+  }
+  const [importCb] = icon;
+  if (!importCb) {
+    return;
+  }
+  const Icon = Loadable({
+    loader: () => importCb().then(module => module.default),
+    loading: () => null
+  }); // because we're using dynamic loading here, TS will not be able to infer the type
+
+  if (fg('platform_navx_smart_link_icon_label_a11y')) {
+    const descriptorLabel = icon[1] || ''; // NAVX-4354: Combine into const [importCb] = icon; above
+    const label = (showIconLabel !== null && showIconLabel !== void 0 ? showIconLabel : true) ? descriptorLabel : '';
+    return /*#__PURE__*/React.createElement(Icon, {
+      testId: "document-file-format-icon",
+      label: label
+    });
+  } else {
+    return /*#__PURE__*/React.createElement(Icon, {
+      testId: "document-file-format-icon"
+    });
+  }
+};

package/dist/es2019/utils/get-iframe-sandbox-attribute.js

@@ -0,0 +1,7 @@
+export const getIframeSandboxAttribute = isTrusted => {
+  if (isTrusted) {
+    return undefined;
+  }
+  const sandboxPermissions = 'allow-downloads allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-same-origin allow-scripts';
+  return sandboxPermissions;
+};

package/dist/es2019/utils/get-is-ai-summary-enabled.js

@@ -0,0 +1,4 @@
+export const getIsAISummaryEnabled = (isAdminHubAIEnabled = false, response) => {
+  var _response$meta, _response$meta$suppor;
+  return Boolean(isAdminHubAIEnabled && (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('AISummary')));
+};