@atlaskit/editor-card-provider 1.0.0

package/dist/cjs/transformer.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transformer = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var Transformer = /*#__PURE__*/function () {
+  function Transformer() {
+    (0, _classCallCheck2.default)(this, Transformer);
+  }
+  (0, _createClass2.default)(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;
+}();
+exports.Transformer = Transformer;

package/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStatus = void 0;
+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';
+  }
+};
+exports.getStatus = getStatus;

package/dist/cjs/version.json

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

package/dist/es2019/api.js

@@ -0,0 +1,37 @@
+const ALLOWED_RESPONSE_STATUS_CODES = [200, 401, 404];
+export class NetworkError extends Error {
+  constructor(error) {
+    super(error);
+  }
+}
+
+// NOTE: This is copied from @atlaskit/link-provider as we are in the middle of a deprecation.
+// To read more, see https://hello.atlassian.net/browse/ENGHEALTH-661
+// Also: https://product-fabric.atlassian.net/browse/EDM-5755
+export async function request(method, url, data, headers) {
+  const requestConfig = {
+    method,
+    credentials: 'include',
+    headers: {
+      Accept: 'application/json',
+      'Cache-Control': 'no-cache',
+      'Content-Type': 'application/json',
+      ...headers
+    },
+    ...(data ? {
+      body: JSON.stringify(data)
+    } : {})
+  };
+  try {
+    const response = await fetch(url, requestConfig);
+    if (response.ok || ALLOWED_RESPONSE_STATUS_CODES.includes(response.status)) {
+      return await response.json();
+    }
+    throw response;
+  } catch (error) {
+    if (typeof error === 'string' || error instanceof TypeError) {
+      throw new NetworkError(error);
+    }
+    throw error;
+  }
+}

package/dist/es2019/environments.js

@@ -0,0 +1,36 @@
+// NOTE: This is copied from @atlaskit/link-provider.
+// This should be moved into @atlaskit/linking-common, to be done in
+// https://product-fabric.atlassian.net/browse/EDM-6042
+const devBaseUrl = 'https://api-private.dev.atlassian.com';
+const stgBaseUrl = 'https://pug.jira-dev.com/gateway/api';
+const prodBaseUrl = 'https://api-private.atlassian.com';
+export const BaseUrls = {
+  dev: devBaseUrl,
+  development: devBaseUrl,
+  stg: stgBaseUrl,
+  staging: stgBaseUrl,
+  prd: prodBaseUrl,
+  prod: prodBaseUrl,
+  production: prodBaseUrl
+};
+export const getBaseUrl = envKey => {
+  // If an environment is provided, then use Stargate.
+  if (envKey) {
+    return envKey in BaseUrls ? BaseUrls[envKey] : prodBaseUrl;
+  }
+
+  // Otherwise, use the current origin of the page.
+  return window.location.origin;
+};
+export const getResolverUrl = (envKey, baseUrlOverride) => {
+  // If an environment is provided, then use Stargate directly for requests.
+  if (envKey || baseUrlOverride) {
+    const baseUrl = baseUrlOverride || getBaseUrl(envKey);
+    return `${baseUrl}/object-resolver`;
+  } else {
+    // Otherwise, we fallback to using the Edge Proxy to access Stargate,
+    // which fixes some cookie issues with strict Browser policies.
+    return '/gateway/api/object-resolver';
+  }
+};
+export default BaseUrls;

package/dist/es2019/index.js

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

package/dist/es2019/provider.js

@@ -0,0 +1,182 @@
+// 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';
+const BATCH_WAIT_TIME = 50;
+const isJiraRoadMap = url => url.match(/^https:\/\/.*?\/jira\/software\/(c\/)?projects\/[^\/]+?\/boards\/.*?\/roadmap\/?/);
+const isPolarisView = url => url.match(/^https:\/\/.*?\/jira\/polaris\/projects\/[^\/]+?\/ideas\/view\/\d+$|^https:\/\/.*?\/secure\/JiraProductDiscoveryAnonymous\.jspa\?hash=\w+|^https:\/\/.*?\/jira\/polaris\/share\/\w+/);
+const isJwmView = url => url.match(/^https:\/\/.*?\/jira\/core\/projects\/[^\/]+?\/(timeline|calendar|list|board|summary|(form\/[^\/]+?))\/?/);
+const isGiphyMedia = url => url.match(/^https:\/\/(.*?\.)?giphy\.com\/(gifs|media|clips)\//);
+const isProformaView = url => url.match(/^https:\/\/[^/]+\/jira\/(core|software(\/c)?|servicedesk)\/projects\/\w+\/forms\/form\/direct\/\d+\/\d+.*$/);
+export class EditorCardProvider {
+  constructor(envKey, baseUrlOverride) {
+    this.baseUrl = baseUrlOverride || getBaseUrl(envKey);
+    this.resolverUrl = getResolverUrl(envKey, baseUrlOverride);
+    this.transformer = new Transformer();
+    this.requestHeaders = {
+      Origin: this.baseUrl
+    };
+    this.providersLoader = new DataLoader(keys => this.batchProviders(keys), {
+      batchScheduleFn: callback => setTimeout(callback, BATCH_WAIT_TIME)
+    });
+    this.cardClient = new CardClient(envKey, baseUrlOverride);
+  }
+  async batchProviders(keys) {
+    // EDM-2205: Batch requests in the case that user paste multiple links at
+    // once. This is so that only one /providersData is being called.
+    const providersData = await this.fetchProvidersData();
+    return keys.map(() => providersData);
+  }
+  async check(resourceUrl) {
+    try {
+      const response = await this.cardClient.fetchData(resourceUrl);
+      if (getStatus(response) !== 'not_found') {
+        return true;
+      }
+    } catch (e) {
+      return false;
+    }
+  }
+  async fetchProvidersData() {
+    const endpoint = `${this.resolverUrl}/providers`;
+    const response = await api.request('post', endpoint, undefined, this.requestHeaders);
+    return {
+      patterns: response.providers.reduce((allSources, provider) => {
+        return allSources.concat(provider.patterns);
+      }, []),
+      userPreferences: response.userPreferences
+    };
+  }
+  async loadProviderData() {
+    try {
+      this.providersData = await this.providersLoader.load('providersData');
+    } catch (err) {
+      // eslint-disable-next-line
+      console.error('failed to fetch /providers', err);
+      this.providersLoader.clear('providerData');
+      return undefined;
+    }
+  }
+  async findPattern(url) {
+    return !!(await this.findPatternData(url)) || !!(await this.check(url));
+  }
+  doesUrlMatchPath(path, url) {
+    // Using [a-zA-Z0-9] here instead of \w since that includes underscores
+    const startingRegex = new RegExp(/^[a-zA-Z0-9]/).test(path) ? '(^|[^a-zA-Z0-9])' : '';
+    const endingRegex = new RegExp(/[a-zA-Z0-9]$/).test(path) ? '($|[^a-zA-Z0-9])' : '';
+    const escapedPath = path.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const regexPattern = new RegExp(`${startingRegex}${escapedPath}${endingRegex}`);
+    return regexPattern.test(url);
+  }
+  async findUserPreference(url) {
+    var _this$providersData;
+    if (!this.providersData) {
+      await this.loadProviderData();
+    }
+    const userPreferences = (_this$providersData = this.providersData) === null || _this$providersData === void 0 ? void 0 : _this$providersData.userPreferences;
+    if (userPreferences) {
+      const {
+        defaultAppearance,
+        appearances
+      } = userPreferences;
+      const allMatchedLabeledAppearances = appearances.filter(({
+        urlSegment
+      }) => this.doesUrlMatchPath(urlSegment, url));
+      if (allMatchedLabeledAppearances.length > 0) {
+        const longestMatchedLabeledAppearance = allMatchedLabeledAppearances.reduce((previousLabeledAppearance, currentLabeledAppearance) => previousLabeledAppearance.urlSegment.length > currentLabeledAppearance.urlSegment.length ? previousLabeledAppearance : currentLabeledAppearance);
+        return longestMatchedLabeledAppearance.appearance;
+      }
+      if (defaultAppearance !== 'inline') {
+        return defaultAppearance;
+      }
+    }
+  }
+  async findPatternData(url) {
+    var _this$providersData2;
+    if (!this.providersData) {
+      await this.loadProviderData();
+    }
+    return (_this$providersData2 = this.providersData) === null || _this$providersData2 === void 0 ? void 0 : _this$providersData2.patterns.find(pattern => url.match(pattern.source));
+  }
+  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
+   */
+  async canBeResolvedAsEmbed(url) {
+    try {
+      const details = await this.cardClient.fetchData(url);
+      const data = details && details.data;
+      if (!data) {
+        return false;
+      }
+      // Imagine response is "unauthorized". We won't be able to tell if even after auth
+      // page going to have preview. Yes, we can show auth view for embed. But what if even after
+      // success auth flow there won't be preview? We will already have ugly embed ADF.
+      // Being on a safe side - if we get anything but resolved - we decide it can't be an embed.
+      if (getStatus(details) !== 'resolved') {
+        return false;
+      }
+      const preview = extractPreview(data, 'web');
+      return !!preview;
+    } catch (e) {
+      return false;
+    }
+  }
+  async resolve(url, appearance, shouldForceAppearance) {
+    try {
+      if (shouldForceAppearance === true) {
+        // At this point we don't need to check pattern nor call `check` because manual change means
+        // this url is already supported and can be resolved. We want to ignore all other options and
+        // respect user's choice.
+        return this.transformer.toAdf(url, appearance);
+      }
+      const hardCodedAppearance = this.getHardCodedAppearance(url);
+      const [matchedProviderPattern, userPreference] = await Promise.all([this.findPatternData(url), this.findUserPreference(url)]);
+      if (shouldForceAppearance === false && userPreference === 'url') {
+        return Promise.reject(undefined);
+      }
+      let isSupported = !!matchedProviderPattern || (await this.check(url));
+      if (isSupported) {
+        const providerDefaultAppearance = matchedProviderPattern === null || matchedProviderPattern === void 0 ? void 0 : matchedProviderPattern.defaultView;
+        let 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') {
+          const canItBeEmbed = await this.canBeResolvedAsEmbed(url);
+          if (!canItBeEmbed) {
+            preferredAppearance = 'inline';
+          }
+        }
+        return this.transformer.toAdf(url, preferredAppearance);
+      }
+    } catch (e) {
+      // eslint-disable-next-line
+      console.warn(`Error when trying to check Smart Card url "${url}"${e instanceof Error ? ` - ${e.name} ${e.message}` : ''}`, e);
+    }
+    return Promise.reject(undefined);
+  }
+}
+export const editorCardProvider = new EditorCardProvider();

package/dist/es2019/transformer.js

@@ -0,0 +1,37 @@
+export class Transformer {
+  buildInlineAdf(url) {
+    return {
+      type: 'inlineCard',
+      attrs: {
+        url
+      }
+    };
+  }
+  buildBlockAdf(url) {
+    return {
+      type: 'blockCard',
+      attrs: {
+        url
+      }
+    };
+  }
+  buildEmbedAdf(url) {
+    return {
+      type: 'embedCard',
+      attrs: {
+        url,
+        layout: 'wide'
+      }
+    };
+  }
+  toAdf(url, appearance) {
+    switch (appearance) {
+      case 'inline':
+        return this.buildInlineAdf(url);
+      case 'block':
+        return this.buildBlockAdf(url);
+      case 'embed':
+        return this.buildEmbedAdf(url);
+    }
+  }
+}

package/dist/es2019/types.js

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

package/dist/es2019/utils.js

@@ -0,0 +1,20 @@
+export const getStatus = ({
+  meta
+}) => {
+  const {
+    access,
+    visibility
+  } = meta;
+  switch (access) {
+    case 'forbidden':
+      if (visibility === 'not_found') {
+        return 'not_found';
+      } else {
+        return 'forbidden';
+      }
+    case 'unauthorized':
+      return 'unauthorized';
+    default:
+      return 'resolved';
+  }
+};

package/dist/es2019/version.json

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

package/dist/esm/api.js

@@ -0,0 +1,82 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 = 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; }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+var ALLOWED_RESPONSE_STATUS_CODES = [200, 401, 404];
+export var NetworkError = /*#__PURE__*/function (_Error) {
+  _inherits(NetworkError, _Error);
+  var _super = _createSuper(NetworkError);
+  function NetworkError(error) {
+    _classCallCheck(this, NetworkError);
+    return _super.call(this, error);
+  }
+  return _createClass(NetworkError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+// NOTE: This is copied from @atlaskit/link-provider as we are in the middle of a deprecation.
+// To read more, see https://hello.atlassian.net/browse/ENGHEALTH-661
+// Also: https://product-fabric.atlassian.net/browse/EDM-5755
+export function request(_x, _x2, _x3, _x4) {
+  return _request.apply(this, arguments);
+}
+function _request() {
+  _request = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(method, url, data, headers) {
+    var requestConfig, response;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            requestConfig = _objectSpread({
+              method: method,
+              credentials: 'include',
+              headers: _objectSpread({
+                Accept: 'application/json',
+                'Cache-Control': 'no-cache',
+                'Content-Type': 'application/json'
+              }, headers)
+            }, data ? {
+              body: JSON.stringify(data)
+            } : {});
+            _context.prev = 1;
+            _context.next = 4;
+            return fetch(url, requestConfig);
+          case 4:
+            response = _context.sent;
+            if (!(response.ok || ALLOWED_RESPONSE_STATUS_CODES.includes(response.status))) {
+              _context.next = 9;
+              break;
+            }
+            _context.next = 8;
+            return response.json();
+          case 8:
+            return _context.abrupt("return", _context.sent);
+          case 9:
+            throw response;
+          case 12:
+            _context.prev = 12;
+            _context.t0 = _context["catch"](1);
+            if (!(typeof _context.t0 === 'string' || _context.t0 instanceof TypeError)) {
+              _context.next = 16;
+              break;
+            }
+            throw new NetworkError(_context.t0);
+          case 16:
+            throw _context.t0;
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[1, 12]]);
+  }));
+  return _request.apply(this, arguments);
+}

package/dist/esm/environments.js

@@ -0,0 +1,36 @@
+// NOTE: This is copied from @atlaskit/link-provider.
+// This should be moved into @atlaskit/linking-common, to be done in
+// https://product-fabric.atlassian.net/browse/EDM-6042
+var devBaseUrl = 'https://api-private.dev.atlassian.com';
+var stgBaseUrl = 'https://pug.jira-dev.com/gateway/api';
+var prodBaseUrl = 'https://api-private.atlassian.com';
+export var BaseUrls = {
+  dev: devBaseUrl,
+  development: devBaseUrl,
+  stg: stgBaseUrl,
+  staging: stgBaseUrl,
+  prd: prodBaseUrl,
+  prod: prodBaseUrl,
+  production: prodBaseUrl
+};
+export var getBaseUrl = function getBaseUrl(envKey) {
+  // If an environment is provided, then use Stargate.
+  if (envKey) {
+    return envKey in BaseUrls ? BaseUrls[envKey] : prodBaseUrl;
+  }
+
+  // Otherwise, use the current origin of the page.
+  return window.location.origin;
+};
+export var getResolverUrl = function getResolverUrl(envKey, baseUrlOverride) {
+  // If an environment is provided, then use Stargate directly for requests.
+  if (envKey || baseUrlOverride) {
+    var baseUrl = baseUrlOverride || getBaseUrl(envKey);
+    return "".concat(baseUrl, "/object-resolver");
+  } else {
+    // Otherwise, we fallback to using the Edge Proxy to access Stargate,
+    // which fixes some cookie issues with strict Browser policies.
+    return '/gateway/api/object-resolver';
+  }
+};
+export default BaseUrls;

package/dist/esm/index.js

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