@atlaskit/smart-card 17.0.0 → 17.2.1

package/dist/esm/extractors/flexible/icon/extract-file-formatIcon.js

@@ -0,0 +1,108 @@
+import { IconType } from '../../../constants';
+
+var extractFileFormatIcon = function extractFileFormatIcon(fileFormat) {
+  switch (fileFormat) {
+    // Generic documents
+    case 'folder':
+      return [IconType.Folder, 'Folder'];
+
+    case 'text/plain':
+    case 'application/vnd.oasis.opendocument.text':
+    case 'application/vnd.apple.pages':
+      return [IconType.Document, 'Document'];
+
+    case 'application/pdf':
+      return [IconType.PDF, 'PDF document'];
+
+    case 'application/vnd.oasis.opendocument.presentation':
+    case 'application/vnd.apple.keynote':
+      return [IconType.Presentation, 'Presentation'];
+
+    case 'application/vnd.oasis.opendocument.spreadsheet':
+    case 'application/vnd.apple.numbers':
+      return [IconType.Spreadsheet, 'Spreadsheet'];
+    // Google Drive
+
+    case 'application/vnd.google-apps.document':
+      return [IconType.GoogleDocs, 'Google Docs'];
+
+    case 'application/vnd.google-apps.form':
+      return [IconType.GoogleForms, 'Google Form'];
+
+    case 'application/vnd.google-apps.spreadsheet':
+      return [IconType.GoogleSheets, 'Google Sheets'];
+
+    case 'application/vnd.google-apps.presentation':
+      return [IconType.GoogleSlides, 'Google Slides'];
+    // Microsoft
+
+    case 'application/vnd.ms-excel':
+    case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
+      return [IconType.MSExcel, 'Excel spreadsheet'];
+
+    case 'application/vnd.ms-powerpoint':
+    case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
+      return [IconType.MSPowerpoint, 'PowerPoint presentation'];
+
+    case 'application/msword':
+    case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+      return [IconType.MSWord, 'Word document'];
+
+    case 'image/png':
+    case 'image/jpeg':
+    case 'image/bmp':
+    case 'image/webp':
+    case 'image/svg+xml':
+      return [IconType.Image, 'Image'];
+
+    case 'image/gif':
+      return [IconType.GIF, 'GIF'];
+
+    case 'audio/midi':
+    case 'audio/mpeg':
+    case 'audio/webm':
+    case 'audio/ogg':
+    case 'audio/wav':
+      return [IconType.Audio, 'Audio'];
+
+    case 'video/mp4':
+    case 'video/quicktime':
+    case 'video/mov':
+    case 'video/webm':
+    case 'video/ogg':
+    case 'video/x-ms-wmv':
+    case 'video/x-msvideo':
+      return [IconType.Video, 'Video'];
+    // Others
+
+    case 'text/css':
+    case 'text/html':
+    case 'application/javascript':
+      return [IconType.Code, 'Source Code'];
+
+    case 'application/zip':
+    case 'application/x-tar':
+    case 'application/x-gtar':
+    case 'application/x-7z-compressed':
+    case 'application/x-apple-diskimage':
+    case 'application/vnd.rar':
+      return [IconType.Archive, 'Archive'];
+
+    case 'application/dmg':
+      return [IconType.Executable, 'Executable'];
+
+    case 'application/sketch':
+      return [IconType.Sketch, 'Sketch'];
+
+    case 'application/octet-stream':
+      return [IconType.Generic, 'Binary file'];
+
+    case 'application/invision.prototype':
+      return [IconType.Generic, 'Prototype'];
+
+    default:
+      return undefined;
+  }
+};
+
+export default extractFileFormatIcon;

package/dist/esm/extractors/flexible/icon/extract-icon-renderer.js

@@ -0,0 +1,20 @@
+var sanitizeEmojiValue = function sanitizeEmojiValue(value) {
+  return value && value.replace(/['"]+/g, '').replace(/null/, '') || '';
+};
+
+var extractIconRenderer = function extractIconRenderer(data, renderers) {
+  var prefix = data['atlassian:titlePrefix'];
+
+  if ((prefix === null || prefix === void 0 ? void 0 : prefix['@type']) === 'atlassian:Emoji') {
+    var emojiId = sanitizeEmojiValue(prefix['text']);
+    var emojiRenderer = renderers === null || renderers === void 0 ? void 0 : renderers.emoji;
+
+    if (emojiId && emojiRenderer) {
+      return function () {
+        return emojiRenderer(emojiId);
+      };
+    }
+  }
+};
+
+export default extractIconRenderer;

package/dist/esm/extractors/flexible/icon/extract-jira-task-icon.js

@@ -0,0 +1,37 @@
+import { IconType } from '../../../constants';
+
+var extractJiraTaskIcon = function extractJiraTaskIcon(taskType) {
+  var label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Task';
+
+  switch (taskType) {
+    case 'JiraBug':
+      return [IconType.Bug, label];
+
+    case 'JiraChange':
+      return [IconType.Change, label];
+
+    case 'JiraEpic':
+      return [IconType.Epic, label];
+
+    case 'JiraIncident':
+      return [IconType.Incident, label];
+
+    case 'JiraProblem':
+      return [IconType.Problem, label];
+
+    case 'JiraServiceRequest':
+      return [IconType.ServiceRequest, label];
+
+    case 'JiraStory':
+      return [IconType.Story, label];
+
+    case 'JiraSubTask':
+      return [IconType.SubTask, label];
+
+    case 'JiraTask':
+    default:
+      return [IconType.Task, label];
+  }
+};
+
+export default extractJiraTaskIcon;

package/dist/esm/extractors/flexible/icon/extract-jsonld-data-icon.js

@@ -0,0 +1,104 @@
+import { CONFLUENCE_GENERATOR_ID, JIRA_GENERATOR_ID } from '../../constants';
+import extractDocumentTypeIcon from './extract-document-type-icon';
+import extractFileFormatIcon from './extract-file-formatIcon';
+import extractJiraTaskIcon from './extract-jira-task-icon';
+import extractProviderIcon from './extract-provider-icon';
+import extractUrlIcon from './extract-url-icon';
+import { extractTaskType } from '../../common/lozenge';
+import { extractTitle } from '../../common/primitives';
+import { extractorPriorityMap as priorityMap } from '../../common/icon/priority';
+import { IconType } from '../../../constants';
+
+var extractTask = function extractTask(data, label) {
+  var _ref = extractTaskType(data) || {},
+      id = _ref.id,
+      url = _ref.icon;
+
+  var taskType = id === null || id === void 0 ? void 0 : id.split('#').pop();
+  var taskIcon = url ? [undefined, label, url] : undefined;
+  return {
+    taskType: taskType,
+    taskIcon: taskIcon
+  };
+};
+
+var extractType = function extractType(jsonLd) {
+  var type = jsonLd['@type'];
+  return Array.isArray(type) ? type.sort(function (a, b) {
+    return priorityMap[b] - priorityMap[a];
+  })[0] : type;
+};
+
+var isConfluenceProvider = function isConfluenceProvider(provider) {
+  return provider === CONFLUENCE_GENERATOR_ID;
+};
+
+var isJiraProvider = function isJiraProvider(provider) {
+  return provider === JIRA_GENERATOR_ID;
+};
+
+var isNativeProvider = function isNativeProvider(provider) {
+  return isConfluenceProvider(provider) || isJiraProvider(provider);
+};
+
+var extractJsonldDataIcon = function extractJsonldDataIcon(data) {
+  var generator = data.generator;
+  var label = extractTitle(data);
+  var type = extractType(data);
+  var urlIcon = extractUrlIcon(data.icon, label);
+  var provider = generator === null || generator === void 0 ? void 0 : generator['@id'];
+  var providerIcon = extractProviderIcon(provider, generator === null || generator === void 0 ? void 0 : generator.icon, label);
+
+  switch (type) {
+    case 'Document':
+    case 'schema:BlogPosting':
+    case 'schema:DigitalDocument':
+    case 'schema:TextDigitalDocument':
+    case 'schema:PresentationDigitalDocument':
+    case 'schema:SpreadsheetDigitalDocument':
+    case 'atlassian:Template':
+    case 'atlassian:UndefinedLink':
+      // If we encounter a native provider, we privilege the
+      // icon generated by its mime type and document type.
+      // Otherwise, we privilege the provider icon,
+      // followed by mime type and document type icon.
+      var documentData = data;
+      var fileFormat = documentData === null || documentData === void 0 ? void 0 : documentData['schema:fileFormat'];
+      var fileFormatIcon = extractFileFormatIcon(fileFormat);
+      var documentTypeIcon = extractDocumentTypeIcon(type, label);
+      return isNativeProvider(provider) ? fileFormatIcon || documentTypeIcon || providerIcon : providerIcon || fileFormatIcon || documentTypeIcon;
+
+    case 'atlassian:Task':
+      var taskLabel = label || 'Task';
+
+      if (isJiraProvider(provider)) {
+        var _extractTask = extractTask(data),
+            taskType = _extractTask.taskType,
+            taskIcon = _extractTask.taskIcon;
+
+        return taskType === 'JiraCustomTaskType' ? taskIcon || urlIcon || providerIcon || [IconType.Task, taskLabel] : extractJiraTaskIcon(taskType, taskLabel);
+      }
+
+      return [IconType.Task, taskLabel];
+
+    case 'atlassian:Project':
+      return urlIcon || [IconType.Project, label || 'Project'];
+
+    case 'atlassian:SourceCodeCommit':
+      return [IconType.Commit, label || 'Commit'];
+
+    case 'atlassian:SourceCodePullRequest':
+      return [IconType.PullRequest, label || 'Pull request'];
+
+    case 'atlassian:SourceCodeReference':
+      return [IconType.Branch, label || 'Reference'];
+
+    case 'atlassian:SourceCodeRepository':
+      return [IconType.Repo, label || 'Repository'];
+
+    default:
+      return providerIcon;
+  }
+};
+
+export default extractJsonldDataIcon;

package/dist/esm/extractors/flexible/icon/extract-provider-icon.js

@@ -0,0 +1,17 @@
+import { CONFLUENCE_GENERATOR_ID, JIRA_GENERATOR_ID } from '../../constants';
+import { IconType } from '../../../constants';
+import extractUrlIcon from './extract-url-icon';
+
+var extractProviderIcon = function extractProviderIcon(provider, icon, label) {
+  if (provider === CONFLUENCE_GENERATOR_ID) {
+    return [IconType.Confluence, label || 'Confluence'];
+  }
+
+  if (provider === JIRA_GENERATOR_ID) {
+    return [IconType.Jira, label || 'Jira'];
+  }
+
+  return extractUrlIcon(icon, label);
+};
+
+export default extractProviderIcon;

package/dist/esm/extractors/flexible/icon/extract-url-icon.js

@@ -0,0 +1,8 @@
+import { extractUrlFromIconJsonLd } from '../../common/utils';
+
+var extractUrlIcon = function extractUrlIcon(icon, label) {
+  var url = icon && extractUrlFromIconJsonLd(icon);
+  return url ? [undefined, label, url] : undefined;
+};
+
+export default extractUrlIcon;

package/dist/esm/extractors/flexible/icon/index.js

@@ -0,0 +1,63 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import extractJsonldDataIcon from './extract-jsonld-data-icon';
+import extractProviderIcon from './extract-provider-icon';
+import { IconType, SmartLinkStatus } from '../../../constants';
+import extractIconRenderer from './extract-icon-renderer';
+export var extractLinkIcon = function extractLinkIcon(response, renderers) {
+  var data = response.data;
+
+  var _ref = extractJsonldDataIcon(data) || [],
+      _ref2 = _slicedToArray(_ref, 3),
+      icon = _ref2[0],
+      label = _ref2[1],
+      url = _ref2[2];
+
+  var render = extractIconRenderer(data, renderers);
+  return {
+    icon: icon,
+    label: label,
+    render: render,
+    url: url
+  };
+};
+export var extractErrorIcon = function extractErrorIcon(response, status) {
+  // Try to get provider icon first.
+  if (response) {
+    var data = response.data;
+    var generator = data.generator;
+    var provider = generator === null || generator === void 0 ? void 0 : generator['@id'];
+
+    var _ref3 = extractProviderIcon(provider, generator === null || generator === void 0 ? void 0 : generator.icon) || [],
+        _ref4 = _slicedToArray(_ref3, 3),
+        icon = _ref4[0],
+        url = _ref4[2];
+
+    if (icon || url) {
+      return {
+        icon: icon,
+        url: url
+      };
+    }
+  } // Otherwise, use fallback icon for each status.
+
+
+  switch (status) {
+    case SmartLinkStatus.Forbidden:
+    case SmartLinkStatus.Unauthorized:
+      return {
+        icon: IconType.Forbidden
+      };
+
+    case SmartLinkStatus.NotFound:
+      return {
+        icon: IconType.Error
+      };
+
+    case SmartLinkStatus.Errored:
+    case SmartLinkStatus.Fallback:
+    default:
+      return {
+        icon: IconType.Default
+      };
+  }
+};

package/dist/esm/extractors/flexible/icon/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/extractors/flexible/index.js

@@ -0,0 +1,36 @@
+import { extractLink, extractTitle } from '../common/primitives';
+import { extractLozenge } from '../common/lozenge';
+import { extractLinkIcon } from './icon';
+import { extractCommentCount, extractCreatedBy, extractModifiedBy, extractProgrammingLanguage, extractSubscriberCount } from './utils';
+import { extractPersonCreatedBy } from '../common/person';
+import { extractPersonsUpdatedBy } from './collaboratorGroup';
+import { extractDateUpdated } from '../common/date/extractDateUpdated';
+import { extractDateCreated } from '../common/date/extractDateCreated';
+import extractPriority from './extract-priority';
+
+var extractFlexibleUiContext = function extractFlexibleUiContext(response, renderers) {
+  if (!response) {
+    return undefined;
+  }
+
+  var data = response.data;
+  var url = extractLink(data);
+  return {
+    authorGroup: extractPersonCreatedBy(data),
+    collaboratorGroup: extractPersonsUpdatedBy(data),
+    commentCount: extractCommentCount(data),
+    createdBy: extractCreatedBy(data),
+    createdOn: extractDateCreated(data),
+    linkIcon: extractLinkIcon(response, renderers),
+    modifiedBy: extractModifiedBy(data),
+    modifiedOn: extractDateUpdated(data),
+    priority: extractPriority(data),
+    programmingLanguage: extractProgrammingLanguage(data),
+    state: extractLozenge(data),
+    subscriberCount: extractSubscriberCount(data),
+    title: extractTitle(data) || url,
+    url: url
+  };
+};
+
+export default extractFlexibleUiContext;

package/dist/esm/extractors/flexible/utils.js

@@ -0,0 +1,29 @@
+import { extractPersonCreatedBy, extractPersonUpdatedBy } from '../common/person';
+
+var extractValue = function extractValue(data, key) {
+  return data === null || data === void 0 ? void 0 : data[key];
+};
+
+export var extractCommentCount = function extractCommentCount(data) {
+  return extractValue(data, 'schema:commentCount');
+};
+export var extractCreatedBy = function extractCreatedBy(data) {
+  var persons = extractPersonCreatedBy(data);
+
+  if (persons && persons.length) {
+    return persons[0].name;
+  }
+};
+export var extractModifiedBy = function extractModifiedBy(data) {
+  var person = extractPersonUpdatedBy(data);
+
+  if (person) {
+    return person.name;
+  }
+};
+export var extractProgrammingLanguage = function extractProgrammingLanguage(data) {
+  return extractValue(data, 'schema:programmingLanguage');
+};
+export var extractSubscriberCount = function extractSubscriberCount(data) {
+  return extractValue(data, 'atlassian:subscriberCount');
+};

package/dist/esm/index.js

@@ -5,9 +5,12 @@ export { APIError } from './client/errors';
 export { Card } from './view/Card';
 export { default as Context } from './state/context';
 export { EmbedResizeMessageListener } from './view/EmbedCard/EmbedResizeMessageListener';
-export { embedHeaderHeight } from '@atlaskit/media-ui/embeds';
+export { embedHeaderHeight } from './view/EmbedCard/components/styled';
 export { SmartLinkEvents } from './utils/analytics/analytics';
 export { useSmartLinkEvents } from './view/SmartLinkEvents/useSmartLinkEvents'; // Classnames for integrators
 
-export { contentFooterClassName, metadataListClassName, blockCardResolvingViewClassName, blockCardResolvedViewClassName, blockCardForbiddenViewClassName, blockCardIconImageClassName, blockCardResolvedViewByClassName, blockCardForbiddenViewLinkClassName, blockCardContentClassName, blockCardContentHeaderClassName, blockCardContentHeaderNameClassName, blockCardNotFoundViewClassName, blockCardErroredViewClassName } from '@atlaskit/media-ui/classNames';
-export { loadingPlaceholderClassName } from './view/CardWithUrl/component-lazy/LazyFallback';
+export { contentFooterClassName, metadataListClassName, blockCardResolvingViewClassName, blockCardResolvedViewClassName, blockCardForbiddenViewClassName, blockCardIconImageClassName, blockCardResolvedViewByClassName, blockCardForbiddenViewLinkClassName, blockCardContentClassName, blockCardContentHeaderClassName, blockCardContentHeaderNameClassName, blockCardNotFoundViewClassName, blockCardErroredViewClassName } from './classNames';
+export { loadingPlaceholderClassName } from './view/CardWithUrl/component-lazy/LazyFallback'; // Flexible UI
+
+export { ActionName, ElementName, SmartLinkDirection, SmartLinkPosition, SmartLinkSize, SmartLinkTheme } from './constants';
+export { MetadataBlock, TitleBlock } from './view/FlexibleCard/components/blocks';

package/dist/esm/messages.js

@@ -0,0 +1,128 @@
+import { defineMessages } from 'react-intl-next';
+export var messages = defineMessages({
+  cannot_connect: {
+    id: 'fabric.linking.cannot_connect',
+    defaultMessage: "Can't connect, try again",
+    description: 'Error for when a provided link is not found.'
+  },
+  cannot_find_link: {
+    id: 'fabric.linking.cannot_find_link',
+    defaultMessage: "Can't find link",
+    description: 'Error for when a provided link is not found.'
+  },
+  click_to_join: {
+    id: 'fabric.linking.click_to_join',
+    defaultMessage: 'Join {context} to view this issue',
+    description: 'Allows the user join the product or service immediately'
+  },
+  connect_link_account: {
+    id: 'fabric.linking.connect_link_account',
+    defaultMessage: 'Connect to preview',
+    description: 'Shown when a user does not have access to a link, but can connect their external account to view the link.'
+  },
+  created_by: {
+    id: 'fabric.linking.created_by',
+    defaultMessage: 'Created by {context}',
+    description: 'Indicates the person or entity that created the resource.'
+  },
+  created_on: {
+    id: 'fabric.linking.create_on',
+    defaultMessage: 'Created {context}',
+    description: 'Indicated when entity was created'
+  },
+  delete: {
+    id: 'fabric.linking.delete',
+    defaultMessage: 'Delete',
+    description: 'Allow a user to delete a link'
+  },
+  modified_by: {
+    id: 'fabric.linking.updated_by',
+    defaultMessage: 'Modified by {context}',
+    description: 'Indicates the person or entity that modified the resource.'
+  },
+  modified_on: {
+    id: 'fabric.linking.modified_on',
+    defaultMessage: 'Updated {context}',
+    description: 'Indicated when entity was modified'
+  },
+  priority_blocker: {
+    id: 'fabric.linking.priority_blocker',
+    defaultMessage: 'Blocker',
+    description: 'Indicated priority as blocker'
+  },
+  priority_critical: {
+    id: 'fabric.linking.priority_critical',
+    defaultMessage: 'Critical',
+    description: 'Indicated priority as critical'
+  },
+  priority_high: {
+    id: 'fabric.linking.priority_high',
+    defaultMessage: 'High',
+    description: 'Indicated priority as high'
+  },
+  priority_highest: {
+    id: 'fabric.linking.priority_highest',
+    defaultMessage: 'Highest',
+    description: 'Indicated priority as highest'
+  },
+  priority_low: {
+    id: 'fabric.linking.priority_low',
+    defaultMessage: 'Low',
+    description: 'Indicated priority as low'
+  },
+  priority_lowest: {
+    id: 'fabric.linking.priority_lowest',
+    defaultMessage: 'Lowest',
+    description: 'Indicated priority as lowest'
+  },
+  priority_major: {
+    id: 'fabric.linking.priority_major',
+    defaultMessage: 'Major',
+    description: 'Indicated priority as major'
+  },
+  priority_medium: {
+    id: 'fabric.linking.priority_medium',
+    defaultMessage: 'Medium',
+    description: 'Indicated priority as medium'
+  },
+  priority_minor: {
+    id: 'fabric.linking.priority_minor',
+    defaultMessage: 'Minor',
+    description: 'Indicated priority as minor'
+  },
+  priority_trivial: {
+    id: 'fabric.linking.priority_trivial',
+    defaultMessage: 'Trivial',
+    description: 'Indicated priority as trivial'
+  },
+  priority_undefined: {
+    id: 'fabric.linking.priority_undefined',
+    defaultMessage: 'Undefined',
+    description: 'Indicated priority as unknown'
+  },
+  forbidden_access: {
+    id: 'fabric.linking.forbidden_access',
+    defaultMessage: 'Your access is forbidden',
+    description: 'Shown when a user does not have access to a resource behind the link.'
+  },
+  pending_request: {
+    id: 'fabric.linking.pending_request',
+    defaultMessage: 'Your access request is pending',
+    description: 'Shown when a user has requested an access but status is pending.'
+  },
+  restricted_link: {
+    id: 'fabric.linking.invalid_permissions',
+    defaultMessage: 'Restricted link, try another account',
+    description: 'Message shown when a user does not have permissions to view an item'
+  },
+  request_access: {
+    id: 'fabric.linking.request_access',
+    defaultMessage: 'Request access to {context} to view this issue',
+    description: 'Allows the user to request access to a product or service'
+  },
+  request_denied: {
+    id: 'fabric.linking.request_denied',
+    defaultMessage: 'Your access request was denied',
+    description: 'The user had request access but the request was denied by a product or service'
+  }
+});

package/dist/esm/providers/editor/transformer.js

@@ -10,7 +10,7 @@ var isPolarisView = function isPolarisView(url) {
 };
 
 var isJwmView = function isJwmView(url) {
-  return url.match(/^https:\/\/.*?\/jira\/core\/projects\/[^\/]+?\/(timeline|calendar)\/?/);
+  return url.match(/^https:\/\/.*?\/jira\/core\/projects\/[^\/]+?\/(timeline|calendar|list|board)\/?/);
 };
 
 var isSlackMessage = function isSlackMessage(url) {

package/dist/esm/ssr.js

@@ -0,0 +1,24 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import React from 'react';
+import { useState } from 'react';
+import uuid from 'uuid';
+import { CardWithUrlContent } from './view/CardWithUrl/component';
+// SSR friendly version of smart-card
+// simplifies the logic around rendering and loading placeholders and
+// only contains whats necessary to render the card on SSR mode
+export var CardSSR = function CardSSR(props) {
+  var _useState = useState(function () {
+    return uuid();
+  }),
+      _useState2 = _slicedToArray(_useState, 1),
+      id = _useState2[0];
+
+  var dispatchAnalytics = function dispatchAnalytics() {}; // we can't dispatch events on SSR, after hydration the we will provide the real callback
+
+
+  return /*#__PURE__*/React.createElement(CardWithUrlContent, _extends({}, props, {
+    id: id,
+    dispatchAnalytics: dispatchAnalytics
+  }));
+};

package/dist/esm/state/flexible-ui-context/index.js

@@ -0,0 +1,5 @@
+import { useContext, createContext } from 'react';
+export var FlexibleUiContext = /*#__PURE__*/createContext(undefined);
+export var useFlexibleUiContext = function useFlexibleUiContext() {
+  return useContext(FlexibleUiContext);
+};

package/dist/esm/state/flexible-ui-context/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/state/reducers/index.js

@@ -2,9 +2,9 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 var _cardReducerMap;
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import * as actions from '../actions/constants';
 import { getStatus } from '../helpers';

package/dist/esm/utils/analytics/analytics.js

@@ -2,9 +2,9 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import { name as packageName, version as packageVersion } from '../../version.json';
 import { getMeasure } from '../performance';