@atlaskit/editor-card-provider 1.0.0

package/dist/esm/provider.js

@@ -0,0 +1,467 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// import setimmediate to temporary fix dataloader 2.0.0 bug
+// @see https://github.com/graphql/dataloader/issues/249
+import 'setimmediate';
+import DataLoader from 'dataloader';
+import { extractPreview } from '@atlaskit/linking-common';
+import { Transformer } from './transformer';
+import { getBaseUrl, getResolverUrl } from './environments';
+import { getStatus } from './utils';
+import { CardClient } from '@atlaskit/link-provider';
+import * as api from './api';
+var BATCH_WAIT_TIME = 50;
+var isJiraRoadMap = function isJiraRoadMap(url) {
+  return url.match(/^https:\/\/.*?\/jira\/software\/(c\/)?projects\/[^\/]+?\/boards\/.*?\/roadmap\/?/);
+};
+var isPolarisView = function isPolarisView(url) {
+  return url.match(/^https:\/\/.*?\/jira\/polaris\/projects\/[^\/]+?\/ideas\/view\/\d+$|^https:\/\/.*?\/secure\/JiraProductDiscoveryAnonymous\.jspa\?hash=\w+|^https:\/\/.*?\/jira\/polaris\/share\/\w+/);
+};
+var isJwmView = function isJwmView(url) {
+  return url.match(/^https:\/\/.*?\/jira\/core\/projects\/[^\/]+?\/(timeline|calendar|list|board|summary|(form\/[^\/]+?))\/?/);
+};
+var isGiphyMedia = function isGiphyMedia(url) {
+  return url.match(/^https:\/\/(.*?\.)?giphy\.com\/(gifs|media|clips)\//);
+};
+var isProformaView = function isProformaView(url) {
+  return url.match(/^https:\/\/[^/]+\/jira\/(core|software(\/c)?|servicedesk)\/projects\/\w+\/forms\/form\/direct\/\d+\/\d+.*$/);
+};
+export var EditorCardProvider = /*#__PURE__*/function () {
+  function EditorCardProvider(envKey, baseUrlOverride) {
+    var _this = this;
+    _classCallCheck(this, EditorCardProvider);
+    this.baseUrl = baseUrlOverride || getBaseUrl(envKey);
+    this.resolverUrl = getResolverUrl(envKey, baseUrlOverride);
+    this.transformer = new Transformer();
+    this.requestHeaders = {
+      Origin: this.baseUrl
+    };
+    this.providersLoader = new DataLoader(function (keys) {
+      return _this.batchProviders(keys);
+    }, {
+      batchScheduleFn: function batchScheduleFn(callback) {
+        return setTimeout(callback, BATCH_WAIT_TIME);
+      }
+    });
+    this.cardClient = new CardClient(envKey, baseUrlOverride);
+  }
+  _createClass(EditorCardProvider, [{
+    key: "batchProviders",
+    value: function () {
+      var _batchProviders = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(keys) {
+        var providersData;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.fetchProvidersData();
+              case 2:
+                providersData = _context.sent;
+                return _context.abrupt("return", keys.map(function () {
+                  return providersData;
+                }));
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function batchProviders(_x) {
+        return _batchProviders.apply(this, arguments);
+      }
+      return batchProviders;
+    }()
+  }, {
+    key: "check",
+    value: function () {
+      var _check = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(resourceUrl) {
+        var response;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.prev = 0;
+                _context2.next = 3;
+                return this.cardClient.fetchData(resourceUrl);
+              case 3:
+                response = _context2.sent;
+                if (!(getStatus(response) !== 'not_found')) {
+                  _context2.next = 6;
+                  break;
+                }
+                return _context2.abrupt("return", true);
+              case 6:
+                _context2.next = 11;
+                break;
+              case 8:
+                _context2.prev = 8;
+                _context2.t0 = _context2["catch"](0);
+                return _context2.abrupt("return", false);
+              case 11:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[0, 8]]);
+      }));
+      function check(_x2) {
+        return _check.apply(this, arguments);
+      }
+      return check;
+    }()
+  }, {
+    key: "fetchProvidersData",
+    value: function () {
+      var _fetchProvidersData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var endpoint, response;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                endpoint = "".concat(this.resolverUrl, "/providers");
+                _context3.next = 3;
+                return api.request('post', endpoint, undefined, this.requestHeaders);
+              case 3:
+                response = _context3.sent;
+                return _context3.abrupt("return", {
+                  patterns: response.providers.reduce(function (allSources, provider) {
+                    return allSources.concat(provider.patterns);
+                  }, []),
+                  userPreferences: response.userPreferences
+                });
+              case 5:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+      function fetchProvidersData() {
+        return _fetchProvidersData.apply(this, arguments);
+      }
+      return fetchProvidersData;
+    }()
+  }, {
+    key: "loadProviderData",
+    value: function () {
+      var _loadProviderData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.prev = 0;
+                _context4.next = 3;
+                return this.providersLoader.load('providersData');
+              case 3:
+                this.providersData = _context4.sent;
+                _context4.next = 11;
+                break;
+              case 6:
+                _context4.prev = 6;
+                _context4.t0 = _context4["catch"](0);
+                // eslint-disable-next-line
+                console.error('failed to fetch /providers', _context4.t0);
+                this.providersLoader.clear('providerData');
+                return _context4.abrupt("return", undefined);
+              case 11:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this, [[0, 6]]);
+      }));
+      function loadProviderData() {
+        return _loadProviderData.apply(this, arguments);
+      }
+      return loadProviderData;
+    }()
+  }, {
+    key: "findPattern",
+    value: function () {
+      var _findPattern = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(url) {
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this.findPatternData(url);
+              case 2:
+                _context5.t0 = !!_context5.sent;
+                if (_context5.t0) {
+                  _context5.next = 7;
+                  break;
+                }
+                _context5.next = 6;
+                return this.check(url);
+              case 6:
+                _context5.t0 = !!_context5.sent;
+              case 7:
+                return _context5.abrupt("return", _context5.t0);
+              case 8:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+      function findPattern(_x3) {
+        return _findPattern.apply(this, arguments);
+      }
+      return findPattern;
+    }()
+  }, {
+    key: "doesUrlMatchPath",
+    value: function doesUrlMatchPath(path, url) {
+      // Using [a-zA-Z0-9] here instead of \w since that includes underscores
+      var startingRegex = new RegExp(/^[a-zA-Z0-9]/).test(path) ? '(^|[^a-zA-Z0-9])' : '';
+      var endingRegex = new RegExp(/[a-zA-Z0-9]$/).test(path) ? '($|[^a-zA-Z0-9])' : '';
+      var escapedPath = path.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+      var regexPattern = new RegExp("".concat(startingRegex).concat(escapedPath).concat(endingRegex));
+      return regexPattern.test(url);
+    }
+  }, {
+    key: "findUserPreference",
+    value: function () {
+      var _findUserPreference = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(url) {
+        var _this$providersData,
+          _this2 = this;
+        var userPreferences, defaultAppearance, appearances, allMatchedLabeledAppearances, longestMatchedLabeledAppearance;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                if (this.providersData) {
+                  _context6.next = 3;
+                  break;
+                }
+                _context6.next = 3;
+                return this.loadProviderData();
+              case 3:
+                userPreferences = (_this$providersData = this.providersData) === null || _this$providersData === void 0 ? void 0 : _this$providersData.userPreferences;
+                if (!userPreferences) {
+                  _context6.next = 12;
+                  break;
+                }
+                defaultAppearance = userPreferences.defaultAppearance, appearances = userPreferences.appearances;
+                allMatchedLabeledAppearances = appearances.filter(function (_ref) {
+                  var urlSegment = _ref.urlSegment;
+                  return _this2.doesUrlMatchPath(urlSegment, url);
+                });
+                if (!(allMatchedLabeledAppearances.length > 0)) {
+                  _context6.next = 10;
+                  break;
+                }
+                longestMatchedLabeledAppearance = allMatchedLabeledAppearances.reduce(function (previousLabeledAppearance, currentLabeledAppearance) {
+                  return previousLabeledAppearance.urlSegment.length > currentLabeledAppearance.urlSegment.length ? previousLabeledAppearance : currentLabeledAppearance;
+                });
+                return _context6.abrupt("return", longestMatchedLabeledAppearance.appearance);
+              case 10:
+                if (!(defaultAppearance !== 'inline')) {
+                  _context6.next = 12;
+                  break;
+                }
+                return _context6.abrupt("return", defaultAppearance);
+              case 12:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
+      function findUserPreference(_x4) {
+        return _findUserPreference.apply(this, arguments);
+      }
+      return findUserPreference;
+    }()
+  }, {
+    key: "findPatternData",
+    value: function () {
+      var _findPatternData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(url) {
+        var _this$providersData2;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                if (this.providersData) {
+                  _context7.next = 3;
+                  break;
+                }
+                _context7.next = 3;
+                return this.loadProviderData();
+              case 3:
+                return _context7.abrupt("return", (_this$providersData2 = this.providersData) === null || _this$providersData2 === void 0 ? void 0 : _this$providersData2.patterns.find(function (pattern) {
+                  return url.match(pattern.source);
+                }));
+              case 4:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
+      function findPatternData(_x5) {
+        return _findPatternData.apply(this, arguments);
+      }
+      return findPatternData;
+    }()
+  }, {
+    key: "getHardCodedAppearance",
+    value: function getHardCodedAppearance(url) {
+      if (isJiraRoadMap(url) || isPolarisView(url) || isJwmView(url) || isGiphyMedia(url) || isProformaView(url)) {
+        return 'embed';
+      }
+    }
+
+    /**
+     * Make a /resolve call and find out if result has embed capability
+     * @param url
+     * @private
+     */
+  }, {
+    key: "canBeResolvedAsEmbed",
+    value: function () {
+      var _canBeResolvedAsEmbed = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(url) {
+        var details, data, preview;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                _context8.prev = 0;
+                _context8.next = 3;
+                return this.cardClient.fetchData(url);
+              case 3:
+                details = _context8.sent;
+                data = details && details.data;
+                if (data) {
+                  _context8.next = 7;
+                  break;
+                }
+                return _context8.abrupt("return", false);
+              case 7:
+                if (!(getStatus(details) !== 'resolved')) {
+                  _context8.next = 9;
+                  break;
+                }
+                return _context8.abrupt("return", false);
+              case 9:
+                preview = extractPreview(data, 'web');
+                return _context8.abrupt("return", !!preview);
+              case 13:
+                _context8.prev = 13;
+                _context8.t0 = _context8["catch"](0);
+                return _context8.abrupt("return", false);
+              case 16:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this, [[0, 13]]);
+      }));
+      function canBeResolvedAsEmbed(_x6) {
+        return _canBeResolvedAsEmbed.apply(this, arguments);
+      }
+      return canBeResolvedAsEmbed;
+    }()
+  }, {
+    key: "resolve",
+    value: function () {
+      var _resolve = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(url, appearance, shouldForceAppearance) {
+        var hardCodedAppearance, _yield$Promise$all, _yield$Promise$all2, matchedProviderPattern, userPreference, isSupported, providerDefaultAppearance, preferredAppearance, canItBeEmbed;
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                _context9.prev = 0;
+                if (!(shouldForceAppearance === true)) {
+                  _context9.next = 3;
+                  break;
+                }
+                return _context9.abrupt("return", this.transformer.toAdf(url, appearance));
+              case 3:
+                hardCodedAppearance = this.getHardCodedAppearance(url);
+                _context9.next = 6;
+                return Promise.all([this.findPatternData(url), this.findUserPreference(url)]);
+              case 6:
+                _yield$Promise$all = _context9.sent;
+                _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+                matchedProviderPattern = _yield$Promise$all2[0];
+                userPreference = _yield$Promise$all2[1];
+                if (!(shouldForceAppearance === false && userPreference === 'url')) {
+                  _context9.next = 12;
+                  break;
+                }
+                return _context9.abrupt("return", Promise.reject(undefined));
+              case 12:
+                _context9.t0 = !!matchedProviderPattern;
+                if (_context9.t0) {
+                  _context9.next = 17;
+                  break;
+                }
+                _context9.next = 16;
+                return this.check(url);
+              case 16:
+                _context9.t0 = _context9.sent;
+              case 17:
+                isSupported = _context9.t0;
+                if (!isSupported) {
+                  _context9.next = 27;
+                  break;
+                }
+                providerDefaultAppearance = matchedProviderPattern === null || matchedProviderPattern === void 0 ? void 0 : matchedProviderPattern.defaultView;
+                preferredAppearance = shouldForceAppearance === undefined ?
+                // Ignore both User and provider's appearances if older editor that doesn't send shouldForceAppearance
+                hardCodedAppearance || appearance :
+                // User preferred appearance. It would be either one that has matching domain/path pattern OR
+                // if user's default choice is NOT "inline" (so, block or embed at this point, url was dealt with above)
+                userPreference ||
+                // If user's default choice is "inline" or user hasn't specified preferences at all,
+                // we check whatever one of the hardcoded providers match url (jira roadmap, polaris, etc)
+                hardCodedAppearance ||
+                // If non match, we see if this provider has default appearance for this particular regexp
+                providerDefaultAppearance ||
+                // If not, we pick what editor (or any other client) requested
+                appearance;
+                if (!(preferredAppearance === userPreference && userPreference === 'embed')) {
+                  _context9.next = 26;
+                  break;
+                }
+                _context9.next = 24;
+                return this.canBeResolvedAsEmbed(url);
+              case 24:
+                canItBeEmbed = _context9.sent;
+                if (!canItBeEmbed) {
+                  preferredAppearance = 'inline';
+                }
+              case 26:
+                return _context9.abrupt("return", this.transformer.toAdf(url, preferredAppearance));
+              case 27:
+                _context9.next = 32;
+                break;
+              case 29:
+                _context9.prev = 29;
+                _context9.t1 = _context9["catch"](0);
+                // eslint-disable-next-line
+                console.warn("Error when trying to check Smart Card url \"".concat(url, "\"").concat(_context9.t1 instanceof Error ? " - ".concat(_context9.t1.name, " ").concat(_context9.t1.message) : ''), _context9.t1);
+              case 32:
+                return _context9.abrupt("return", Promise.reject(undefined));
+              case 33:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this, [[0, 29]]);
+      }));
+      function resolve(_x7, _x8, _x9) {
+        return _resolve.apply(this, arguments);
+      }
+      return resolve;
+    }()
+  }]);
+  return EditorCardProvider;
+}();
+export var editorCardProvider = new EditorCardProvider();

package/dist/esm/transformer.js

@@ -0,0 +1,52 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+export var Transformer = /*#__PURE__*/function () {
+  function Transformer() {
+    _classCallCheck(this, Transformer);
+  }
+  _createClass(Transformer, [{
+    key: "buildInlineAdf",
+    value: function buildInlineAdf(url) {
+      return {
+        type: 'inlineCard',
+        attrs: {
+          url: url
+        }
+      };
+    }
+  }, {
+    key: "buildBlockAdf",
+    value: function buildBlockAdf(url) {
+      return {
+        type: 'blockCard',
+        attrs: {
+          url: url
+        }
+      };
+    }
+  }, {
+    key: "buildEmbedAdf",
+    value: function buildEmbedAdf(url) {
+      return {
+        type: 'embedCard',
+        attrs: {
+          url: url,
+          layout: 'wide'
+        }
+      };
+    }
+  }, {
+    key: "toAdf",
+    value: function toAdf(url, appearance) {
+      switch (appearance) {
+        case 'inline':
+          return this.buildInlineAdf(url);
+        case 'block':
+          return this.buildBlockAdf(url);
+        case 'embed':
+          return this.buildEmbedAdf(url);
+      }
+    }
+  }]);
+  return Transformer;
+}();

package/dist/esm/types.js

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

package/dist/esm/utils.js

@@ -0,0 +1,17 @@
+export var getStatus = function getStatus(_ref) {
+  var meta = _ref.meta;
+  var access = meta.access,
+    visibility = meta.visibility;
+  switch (access) {
+    case 'forbidden':
+      if (visibility === 'not_found') {
+        return 'not_found';
+      } else {
+        return 'forbidden';
+      }
+    case 'unauthorized':
+      return 'unauthorized';
+    default:
+      return 'resolved';
+  }
+};

package/dist/esm/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/editor-card-provider",
+	"version": "1.0.0",
+	"sideEffects": false
+}

package/dist/types/api.d.ts

@@ -0,0 +1,5 @@
+import { JsonLd } from 'json-ld-types';
+export declare class NetworkError extends Error {
+    constructor(error: any);
+}
+export declare function request<T = JsonLd.Response>(method: string, url: string, data?: any, headers?: HeadersInit): Promise<T>;

package/dist/types/environments.d.ts

@@ -0,0 +1,13 @@
+export declare type EnvironmentsKeys = keyof typeof BaseUrls;
+export declare const BaseUrls: {
+    dev: string;
+    development: string;
+    stg: string;
+    staging: string;
+    prd: string;
+    prod: string;
+    production: string;
+};
+export declare const getBaseUrl: (envKey?: "dev" | "development" | "stg" | "staging" | "prd" | "prod" | "production" | undefined) => string;
+export declare const getResolverUrl: (envKey?: "dev" | "development" | "stg" | "staging" | "prd" | "prod" | "production" | undefined, baseUrlOverride?: string | undefined) => string;
+export default BaseUrls;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { EditorCardProvider, editorCardProvider } from './provider';

package/dist/types/provider.d.ts

@@ -0,0 +1,32 @@
+import 'setimmediate';
+import { CardAdf, CardAppearance } from '@atlaskit/linking-common';
+import { CardProvider } from './types';
+import { EnvironmentsKeys } from './environments';
+export declare class EditorCardProvider implements CardProvider {
+    private baseUrl;
+    private resolverUrl;
+    private providersData?;
+    private requestHeaders;
+    private transformer;
+    private providersLoader;
+    private cardClient;
+    constructor(envKey?: EnvironmentsKeys, baseUrlOverride?: string);
+    private batchProviders;
+    private check;
+    private fetchProvidersData;
+    private loadProviderData;
+    findPattern(url: string): Promise<boolean>;
+    private doesUrlMatchPath;
+    private findUserPreference;
+    private findPatternData;
+    private getHardCodedAppearance;
+    /**
+     * Make a /resolve call and find out if result has embed capability
+     * @param url
+     * @private
+     */
+    private canBeResolvedAsEmbed;
+    resolve(url: string, appearance: CardAppearance, shouldForceAppearance?: boolean): Promise<CardAdf>;
+}
+export declare const editorCardProvider: EditorCardProvider;
+export type { CardProvider } from './types';

package/dist/types/transformer.d.ts

@@ -0,0 +1,7 @@
+import { CardAppearance, CardAdf } from '@atlaskit/linking-common';
+export declare class Transformer {
+    private buildInlineAdf;
+    private buildBlockAdf;
+    private buildEmbedAdf;
+    toAdf(url: string, appearance: CardAppearance): CardAdf;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,34 @@
+import { CardAppearance } from '@atlaskit/linking-common';
+export interface CardProvider {
+    resolve(url: string, appearance: CardAppearance, shouldForceAppearance?: boolean): Promise<any>;
+}
+export declare type ORSCheckResponse = {
+    isSupported: boolean;
+};
+declare type DisplayViews = 'inline' | 'block' | 'embed';
+export declare type ProviderPattern = {
+    source: string;
+    supportedViews?: DisplayViews[];
+    defaultView?: DisplayViews;
+};
+declare type Provider = {
+    key: string;
+    patterns: ProviderPattern[];
+};
+export declare type LinkAppearance = CardAppearance | 'url';
+export interface UserPreferences {
+    defaultAppearance: LinkAppearance;
+    appearances: {
+        urlSegment: string;
+        appearance: LinkAppearance;
+    }[];
+}
+export declare type ORSProvidersResponse = {
+    providers: Provider[];
+    userPreferences?: UserPreferences;
+};
+export interface ProvidersData {
+    patterns: ProviderPattern[];
+    userPreferences?: UserPreferences;
+}
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,3 @@
+import { JsonLd } from 'json-ld-types';
+import { CardType } from '@atlaskit/linking-common';
+export declare const getStatus: ({ meta }: JsonLd.Response) => CardType;