@atlaskit/smart-card 16.2.1 → 17.1.0

package/dist/es2019/extractors/common/byline/extractByline.js

@@ -1,5 +1,6 @@
 import React from 'react';
-import { FormattedRelative } from 'react-intl';
+import { FormattedRelativeTime } from 'react-intl-next';
+import { selectUnit } from '@formatjs/intl-utils';
 import { extractPersonUpdatedBy } from '../person/extractPersonUpdatedBy';
 import { extractPersonCreatedBy } from '../person/extractPersonCreatedBy';
 import { extractDateCreated } from '../date/extractDateCreated';
@@ -9,15 +10,25 @@ export const extractByline = jsonLd => {
   const createdAt = extractDateCreated(jsonLd);
 
   if (updatedAt) {
+    const {
+      value,
+      unit
+    } = selectUnit(new Date(updatedAt).getTime());
     const updatedBy = extractPersonUpdatedBy(jsonLd);
-    return /*#__PURE__*/React.createElement("span", null, "Updated ", updatedBy && `by ${updatedBy.name}`, ' ', /*#__PURE__*/React.createElement(FormattedRelative, {
-      value: updatedAt
+    return /*#__PURE__*/React.createElement("span", null, "Updated ", updatedBy && `by ${updatedBy.name}`, ' ', /*#__PURE__*/React.createElement(FormattedRelativeTime, {
+      value: value,
+      unit: unit
     }));
   } else if (createdAt) {
+    const {
+      value,
+      unit
+    } = selectUnit(new Date(createdAt).getTime());
     const createdBy = extractPersonCreatedBy(jsonLd);
     const createdByPerson = extractFirstPerson(createdBy);
-    return /*#__PURE__*/React.createElement("span", null, "Created ", createdByPerson && `by ${createdByPerson.name}`, ' ', /*#__PURE__*/React.createElement(FormattedRelative, {
-      value: createdAt
+    return /*#__PURE__*/React.createElement("span", null, "Created ", createdByPerson && `by ${createdByPerson.name}`, ' ', /*#__PURE__*/React.createElement(FormattedRelativeTime, {
+      value: value,
+      unit: unit
     }));
   }
 };

package/dist/es2019/extractors/common/context/extractAccessContext.js

@@ -1,4 +1,5 @@
-import { ForbiddenAction, messages } from '@atlaskit/media-ui';
+import { messages } from '@atlaskit/media-ui/messages';
+import { ForbiddenAction } from '../../../view/BlockCard/actions/ForbiddenAction';
 export const extractRequestAccessContext = ({
   jsonLd,
   url,

package/dist/es2019/extractors/flexible/collaboratorGroup/index.js

@@ -0,0 +1,10 @@
+import { extractPersonFromJsonLd } from '../../common/utils';
+// Temporary Extractor until https://product-fabric.atlassian.net/browse/EDM-2652 is ready
+export const extractPersonsUpdatedBy = jsonLd => {
+  const updatedBy = jsonLd['atlassian:updatedBy'];
+
+  if (updatedBy) {
+    const extractedPersons = extractPersonFromJsonLd(updatedBy);
+    return extractedPersons ? [extractedPersons] : undefined;
+  }
+};

package/dist/es2019/extractors/flexible/extract-priority.js

@@ -0,0 +1,39 @@
+import { IconType } from '../../constants';
+import { extractUrlFromIconJsonLd } from '../common/utils';
+const priorityMapper = {
+  blocker: IconType.PriorityBlocker,
+  critical: IconType.PriorityCritical,
+  high: IconType.PriorityHigh,
+  highest: IconType.PriorityHighest,
+  low: IconType.PriorityLow,
+  lowest: IconType.PriorityLowest,
+  major: IconType.PriorityMajor,
+  medium: IconType.PriorityMedium,
+  minor: IconType.PriorityMinor,
+  trivial: IconType.PriorityTrivial,
+  undefined: IconType.PriorityUndefined
+};
+
+const extractPriority = data => {
+  const priority = data['atlassian:priority'];
+
+  if (priority) {
+    if (typeof priority === 'string') {
+      const icon = priorityMapper[priority.toLowerCase()];
+
+      if (icon) {
+        return {
+          icon,
+          label: priority
+        };
+      }
+    } else if (priority['@type'] === 'Object') {
+      return {
+        label: priority.name,
+        url: priority.icon && extractUrlFromIconJsonLd(priority.icon)
+      };
+    }
+  }
+};
+
+export default extractPriority;

package/dist/es2019/extractors/flexible/icon/extract-document-type-icon.js

@@ -0,0 +1,31 @@
+import { IconType } from '../../../constants';
+
+const extractDocumentTypeIcon = (documentType, label) => {
+  switch (documentType) {
+    case 'schema:BlogPosting':
+      return [IconType.Blog, label || 'Blog'];
+
+    case 'schema:DigitalDocument':
+      return [IconType.File, label || 'File'];
+
+    case 'schema:TextDigitalDocument':
+      return [IconType.Document, label || 'Document'];
+
+    case 'schema:PresentationDigitalDocument':
+      return [IconType.Presentation, label || 'Presentation'];
+
+    case 'schema:SpreadsheetDigitalDocument':
+      return [IconType.Spreadsheet, label || 'Spreadsheet'];
+
+    case 'atlassian:Template':
+      return [IconType.Template, label || 'Template'];
+
+    case 'atlassian:UndefinedLink':
+      return [IconType.Document, label || 'Undefined link'];
+
+    default:
+      return undefined;
+  }
+};
+
+export default extractDocumentTypeIcon;

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

@@ -0,0 +1,108 @@
+import { IconType } from '../../../constants';
+
+const 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/es2019/extractors/flexible/icon/extract-icon-renderer.js

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

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

@@ -0,0 +1,35 @@
+import { IconType } from '../../../constants';
+
+const extractJiraTaskIcon = (taskType, label = '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/es2019/extractors/flexible/icon/extract-jsonld-data-icon.js

@@ -0,0 +1,96 @@
+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';
+
+const extractTask = (data, label) => {
+  const {
+    id,
+    icon: url
+  } = extractTaskType(data) || {};
+  const taskType = id === null || id === void 0 ? void 0 : id.split('#').pop();
+  const taskIcon = url ? [undefined, label, url] : undefined;
+  return {
+    taskType,
+    taskIcon
+  };
+};
+
+const extractType = jsonLd => {
+  const type = jsonLd['@type'];
+  return Array.isArray(type) ? type.sort((a, b) => priorityMap[b] - priorityMap[a])[0] : type;
+};
+
+const isConfluenceProvider = provider => provider === CONFLUENCE_GENERATOR_ID;
+
+const isJiraProvider = provider => provider === JIRA_GENERATOR_ID;
+
+const isNativeProvider = provider => isConfluenceProvider(provider) || isJiraProvider(provider);
+
+const extractJsonldDataIcon = data => {
+  const generator = data.generator;
+  const label = extractTitle(data);
+  const type = extractType(data);
+  const urlIcon = extractUrlIcon(data.icon, label);
+  const provider = generator === null || generator === void 0 ? void 0 : generator['@id'];
+  const 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.
+      const documentData = data;
+      const fileFormat = documentData === null || documentData === void 0 ? void 0 : documentData['schema:fileFormat'];
+      const fileFormatIcon = extractFileFormatIcon(fileFormat);
+      const documentTypeIcon = extractDocumentTypeIcon(type, label);
+      return isNativeProvider(provider) ? fileFormatIcon || documentTypeIcon || providerIcon : providerIcon || fileFormatIcon || documentTypeIcon;
+
+    case 'atlassian:Task':
+      const taskLabel = label || 'Task';
+
+      if (isJiraProvider(provider)) {
+        const {
+          taskType,
+          taskIcon
+        } = extractTask(data);
+        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/es2019/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';
+
+const 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/es2019/extractors/flexible/icon/extract-url-icon.js

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

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

@@ -0,0 +1,52 @@
+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 const extractLinkIcon = (response, renderers) => {
+  const data = response.data;
+  const [icon, label, url] = extractJsonldDataIcon(data) || [];
+  const render = extractIconRenderer(data, renderers);
+  return {
+    icon,
+    label,
+    render,
+    url
+  };
+};
+export const extractErrorIcon = (response, status) => {
+  // Try to get provider icon first.
+  if (response) {
+    const data = response.data;
+    const generator = data.generator;
+    const provider = generator === null || generator === void 0 ? void 0 : generator['@id'];
+    const [icon,, url] = extractProviderIcon(provider, generator === null || generator === void 0 ? void 0 : generator.icon) || [];
+
+    if (icon || url) {
+      return {
+        icon,
+        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/es2019/extractors/flexible/icon/types.js

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

package/dist/es2019/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';
+
+const extractFlexibleUiContext = (response, renderers) => {
+  if (!response) {
+    return undefined;
+  }
+
+  const data = response.data;
+  const 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
+  };
+};
+
+export default extractFlexibleUiContext;

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

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

package/dist/es2019/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 } 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 { TitleBlock } from './view/FlexibleCard/components/blocks';