@atlassian/atlassian-connect-js 5.3.190

package/src/host/utils/base64.js

@@ -0,0 +1,22 @@
+import { toByteArray, fromByteArray } from 'base64-js';
+
+export function encode(string) {
+  return fromByteArray(
+    new TextEncoder().encode(string)
+  );
+}
+
+export function decode(string) {
+  var padding = 4 - string.length % 4;
+  if (padding === 1) {
+    string += '=';
+  } else if (padding === 2) {
+    string += '==';
+  }
+  return new TextDecoder().decode(toByteArray(string));
+}
+
+export default {
+  encode,
+  decode
+}

package/src/host/utils/button.js

@@ -0,0 +1,10 @@
+class ButtonUtils {
+  // button identifier for XDM. NOT an id attribute
+  randomIdentifier(){
+    return Math.random().toString(16).substring(7);
+  }
+}
+
+var buttonUtilsInstance = new ButtonUtils();
+
+export default buttonUtilsInstance;

package/src/host/utils/cookie.js

@@ -0,0 +1,14 @@
+function prefixCookie (addonKey, name){
+  if (!addonKey || addonKey.length === 0) {
+    throw new Error('addon key must be defined on cookies');
+  }
+
+  if (!name || name.length === 0) {
+    throw new Error('Name must be defined');
+  }
+  return addonKey + '$$' + name;
+}
+
+export default {
+  prefixCookie
+};

package/src/host/utils/dialog.js

@@ -0,0 +1,239 @@
+import util from '../util';
+import buttonUtils from './button';
+import $ from '../dollar';
+import AnalyticsDispatcher from '../dispatchers/analytics_dispatcher';
+
+class DialogUtils {
+  _maxDimension(val, maxPxVal){
+    var parsed = util.stringToDimension(val);
+    var parsedInt = parseInt(parsed, 10);
+    var parsedMaxPxVal = parseInt(maxPxVal, 10);
+
+    if ((parsed.indexOf('%') > -1 && parsedInt >= 100) // %
+      || (parsedInt > parsedMaxPxVal)) { // px
+      return '100%';
+    }
+    return parsed;
+  }
+
+  _closeOnEscape (options){
+    if (options.closeOnEscape === false) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  _size (options){
+    var size = options.size;
+    if (options.size === 'x-large') {
+      size = 'xlarge';
+    }
+    if (options.size !== 'maximum' && options.width === '100%' && options.height === '100%') {
+      size = 'fullscreen';
+    }
+    return size;
+  }
+
+  _header(text){
+    var headerText = '';
+    switch(typeof text) {
+    case 'string':
+      headerText = text;
+      break;
+
+    case 'object':
+      headerText = text.value;
+      break;
+    }
+
+    return headerText;
+  }
+
+  _hint(text){
+    if(typeof text === 'string'){
+      return text;
+    }
+    return '';
+  }
+
+  _chrome(options){
+    var returnval = false;
+    if (typeof options.chrome === 'boolean') {
+      returnval = options.chrome;
+    }
+    if(options.size === 'fullscreen') {
+      returnval = true;
+    }
+    if(options.size === 'maximum') {
+      returnval = false;
+    }
+    return returnval;
+  }
+
+  _width(options){
+    if(options.size) {
+      return undefined;
+    }
+    if(options.width) {
+      return this._maxDimension(options.width, $(window).width());
+    }
+    return '50%';
+  }
+
+  _height(options){
+    if(options.size) {
+      return undefined;
+    }
+    if(options.height) {
+      return this._maxDimension(options.height, $(window).height());
+    }
+    return '50%';
+  }
+
+  _actions(options){
+    var sanitizedActions = [];
+    options = options || {};
+    if (!options.actions) {
+
+      sanitizedActions = [
+        {
+          name: 'submit',
+          identifier: 'submit',
+          text: options.submitText || 'Submit',
+          type: 'primary',
+          disabled: true // disable submit button by default (until the dialog has loaded).
+        },
+        {
+          name: 'cancel',
+          identifier: 'cancel',
+          text: options.cancelText || 'Cancel',
+          type: 'link',
+          immutable: true
+        }
+      ];
+    }
+
+    if(options.buttons) {
+      sanitizedActions = sanitizedActions.concat(this._buttons(options));
+    }
+
+    return sanitizedActions;
+
+  }
+
+  _id(str){
+    if(typeof str !== 'string'){
+      str = Math.random().toString(36).substring(2, 8);
+    }
+    return str;
+  }
+  // user defined action buttons
+  _buttons(options) {
+    var buttons = [];
+    if(options.buttons && Array.isArray(options.buttons)) {
+      options.buttons.forEach((button) => {
+        var text;
+        var identifier;
+        var disabled = false;
+        if(button.text && typeof button.text === 'string') {
+          text = button.text;
+        }
+        if(button.identifier && typeof button.identifier === 'string') {
+          identifier = button.identifier;
+        } else {
+          identifier = buttonUtils.randomIdentifier();
+        }
+        if(button.disabled && button.disabled === true) {
+          disabled = true;
+        }
+
+        buttons.push({
+          text: text,
+          identifier: identifier,
+          type: 'secondary',
+          custom: true,
+          disabled: disabled
+        });
+      });
+    }
+    return buttons;
+  }
+
+  _onHide(options) {
+    var noop = function () {};
+    if (typeof options.onHide === 'function') {
+      return options.onHide;
+    } else {
+      return noop;
+    }
+  }
+
+  sanitizeOptions(options){
+    options = options || {};
+    var sanitized = {
+      chrome: this._chrome(options),
+      header: this._header(options.header),
+      hint: this._hint(options.hint),
+      width: this._width(options),
+      height: this._height(options),
+      $content: options.$content,
+      extension: options.extension,
+      actions: this._actions(options),
+      id: this._id(options.id),
+      size: options.size,
+      closeOnEscape: this._closeOnEscape(options),
+      onHide: this._onHide(options),
+    };
+    sanitized.size = this._size(sanitized);
+
+    return sanitized;
+  }
+  // such a bad idea! this entire concept needs rewriting in the p2 plugin.
+  moduleOptionsFromGlobal(addon_key, key) {
+    var defaultOptions = {
+      chrome: true,
+      hostFrameOffset: 1
+    };
+
+    if(window._AP
+      && window._AP.dialogModules
+      && window._AP.dialogModules[addon_key]
+      && window._AP.dialogModules[addon_key][key]) {
+      return util.extend({}, defaultOptions, window._AP.dialogModules[addon_key][key].options);
+    }
+    return false;
+  }
+
+  // determines information about dialogs that are about to open and are already open
+  trackMultipleDialogOpening(dialogExtension, options) {
+    // check for dialogs that are already open
+    let trackingDescription;
+    let size = this._size(options);
+    if($('.ap-aui-dialog2:visible').length) {
+      // am i in the confluence editor? first check for macro dialogs opened through macro browser, second is editing an existing macro
+      if($('#macro-browser-dialog').length || (AJS.Confluence && AJS.Confluence.Editor && AJS.Confluence.Editor.currentEditMode)) {
+        if (size === 'fullscreen') {
+          trackingDescription = 'connect-macro-multiple-fullscreen';
+        } else {
+          trackingDescription = 'connect-macro-multiple';
+        }
+      } else {
+        trackingDescription = 'connect-multiple';
+      }
+      AnalyticsDispatcher.trackGasV3MultipleDialogOpening(trackingDescription, dialogExtension);
+    }
+  }
+
+  // abstracts and handles a failure to find active dialog
+  assertActiveDialogOrThrow(dialogProvider, addon_key) {
+    if (!dialogProvider.isActiveDialog(addon_key)) {
+      throw new Error('Failed to find an active dialog for: ' + addon_key);
+    }
+  }
+
+}
+
+var dialogUtilsInstance = new DialogUtils();
+
+export default dialogUtilsInstance;

package/src/host/utils/feature-flag.js

@@ -0,0 +1,27 @@
+import FeatureGates from '@atlaskit/feature-gate-js-client';
+import AnalyticsDispatcher from '../dispatchers/analytics_dispatcher';
+
+function getBooleanFeatureFlagStatsig(flagName) {
+  if (FeatureGates.initializeCompleted()) {
+    return FeatureGates.checkGate(flagName);
+  }
+  AnalyticsDispatcher.trackGasV3FeatureFlagDefaultFalse(flagName);
+  console.error(`[ACJS] Feature flag service is not initialised. Default flag '${flagName}' to false`);
+  return false;
+}
+
+
+/**
+ * For all new feature flags, please create them in Statsig
+ * https://hello.atlassian.net/wiki/spaces/ECO/pages/3707522428
+ *
+ * @param {string} flagName Feature flag name
+ * @returns {boolean}
+ */
+export default function getBooleanFeatureFlag(flagName) {
+  return getBooleanFeatureFlagStatsig(flagName);
+}
+
+export const Flags = {
+  getBooleanFeatureFlag,
+}

package/src/host/utils/iframe.js

@@ -0,0 +1,23 @@
+import util from '../util';
+
+export default {
+  optionsToAttributes: function(options){
+    var sanitized = {};
+    if(options && typeof options ==='object'){
+      if(options.width){
+        sanitized.width = util.stringToDimension(options.width);
+      }
+      if(options.height){
+        sanitized.height = util.stringToDimension(options.height);
+      }
+      if (typeof options.sandbox === 'string'){
+        var domElem = document.createElement('iframe');
+        sanitized.sandbox = options.sandbox
+          .split(' ')
+          .filter(value => util.isSupported(domElem, 'sandbox', value, true))
+          .join(' ');
+      }
+    }
+    return sanitized;
+  }
+};

package/src/host/utils/jwt.js

@@ -0,0 +1,60 @@
+import { decode } from './base64';
+import EventDispatcher from '../dispatchers/event_dispatcher';
+var JWT_SKEW = 60; // in seconds.
+
+function parseJwtIssuer(jwt) {
+  return parseJwtClaims(jwt)['iss'];
+}
+
+function parseJwtClaims(jwt) {
+
+  if (null === jwt || '' === jwt) {
+    throw('Invalid JWT: must be neither null nor empty-string.');
+  }
+
+  var firstPeriodIndex = jwt.indexOf('.');
+  var secondPeriodIndex = jwt.indexOf('.', firstPeriodIndex + 1);
+
+  if (firstPeriodIndex < 0 || secondPeriodIndex <= firstPeriodIndex) {
+    throw('Invalid JWT: must contain 2 period (".") characters.');
+  }
+
+  var encodedClaims = jwt.substring(firstPeriodIndex + 1, secondPeriodIndex);
+
+  if (null === encodedClaims || '' === encodedClaims) {
+    throw('Invalid JWT: encoded claims must be neither null nor empty-string.');
+  }
+
+  var claimsString = decode.call(window, encodedClaims);
+  return JSON.parse(claimsString);
+}
+
+function isJwtExpired(jwtString, skew) {
+  if (skew === undefined) {
+    skew = JWT_SKEW;
+  }
+  var claims = parseJwtClaims(jwtString);
+  var expires = 0;
+  var now = Math.floor(Date.now() / 1000); // UTC timestamp now
+  if (claims && claims.exp) {
+    expires = claims.exp;
+  }
+
+  if ((expires - skew) < now){
+    return true;
+  }
+
+  return false;
+
+}
+
+EventDispatcher.register('jwt-skew-set', function(data){
+  JWT_SKEW = data.skew;
+});
+
+
+export default {
+  parseJwtIssuer,
+  parseJwtClaims,
+  isJwtExpired
+}

package/src/host/utils/observe.js

@@ -0,0 +1,34 @@
+const threshold = 0.25;
+let targets = [];
+let observe;
+
+const observed = target => {
+  targets = targets.filter(({ element, callback }) => {
+    if (element === target) {
+      callback();
+      return false;
+    }
+    return true;
+  });
+}
+
+if ('IntersectionObserver' in window &&
+  'IntersectionObserverEntry' in window) {
+  const observer = new IntersectionObserver(entries => {
+    entries.forEach(({ intersectionRatio, target }) => {
+      if (intersectionRatio > 0) {
+        observer.unobserve(target);
+        observed(target);
+      }
+    });
+  }, { threshold });
+  observe = observer.observe.bind(observer);
+}
+
+export default (element, callback) => {
+  if (typeof callback === 'function'
+    && element instanceof Element) {
+    targets.push({ element, callback });
+    observe(element);
+  }
+};

package/src/host/utils/removal-observer.js

@@ -0,0 +1,30 @@
+import HostApi from '../host-api';
+
+export function observeIframeRemoval() {
+  const scopedObserver = new MutationObserver((mutationsList) => {
+    mutationsList.forEach((mutation) => {
+      if (mutation.type === 'childList') {
+        mutation.removedNodes.forEach((node) => {
+          if (node.nodeType !== Node.ELEMENT_NODE) {
+            return;
+          }
+          const onDisconnect = (node) => {
+            HostApi.destroy(node.id);
+          };
+          // Check if the node itself is an iframe
+          if (node.tagName === 'IFRAME' && node.id) {
+            onDisconnect(node);
+          } else {
+            // Check if any iframes exist within the removed node's subtree
+            node.querySelectorAll('iframe[id]').forEach((childNode) => {
+              onDisconnect(childNode);
+            });
+          }
+        });
+      }
+    });
+  });
+
+  scopedObserver.observe(document.body, { childList: true, subtree: true });
+  return scopedObserver;
+}

package/src/host/utils/simplexdm.js

@@ -0,0 +1,58 @@
+import iframeUtils from './iframe';
+import simpleXDM from 'simple-xdm/host';
+import IframeActions from '../actions/iframe_actions';
+import util from '../util';
+import $ from '../dollar';
+import ExtensionConfigurationOptionStore from '../stores/extension_configuration_options_store';
+import getBooleanFeatureFlag from './feature-flag';
+import definePerformanceModule, {ADDON_KEY_CODEBARREL} from '../modules/_performance';
+import defineFeatureFlagModule from '../modules/_featureFlag';
+
+// nowhere better to put this. Wires an extension for oldschool and new enviroments
+function createSimpleXdmExtension(extension){
+  const extensionConfig = extensionConfigSanitizer(extension);
+  const systemExtensionConfigOptions = ExtensionConfigurationOptionStore.get();
+  extension.options = extensionConfig.options = util.extend({}, extensionConfig.options);
+  extension.options.globalOptions = systemExtensionConfigOptions;
+  loadConditionalModules(extension.addon_key);
+  const iframeAttributes = simpleXDM.create(extensionConfig, () => {
+    if(!extension.options.noDOM){
+      extension.$el = $(document.getElementById(extension.id));
+    }
+    IframeActions.notifyBridgeEstablished(extension.$el, extension);
+  }, () => {
+    IframeActions.notifyUnloaded(extension.$el, extension);
+  });
+  // HostApi destroy is relying on previous behaviour of the
+  // iframe component wherein it would call simpleXDM.create(extension)
+  // and then mutate the extension object with the id returned from the
+  // iframeAttributes see changes made in ACJS-760 and ACJS-807
+  extensionConfig.id = iframeAttributes.id;
+  extension.id = iframeAttributes.id;
+  util.extend(iframeAttributes, iframeUtils.optionsToAttributes(extension.options));
+  return {
+    iframeAttributes,
+    extension
+  }
+}
+
+function extensionConfigSanitizer(extension) {
+  return {
+    addon_key: extension.addon_key,
+    key: extension.key,
+    url: extension.url,
+    options: extension.options,
+  };
+}
+
+function loadConditionalModules(addonKey) {
+  if (addonKey === ADDON_KEY_CODEBARREL) {
+    definePerformanceModule();
+  }
+  defineFeatureFlagModule();
+}
+
+export default {
+  createSimpleXdmExtension,
+  extensionConfigSanitizer
+}

package/src/host/utils/url.js

@@ -0,0 +1,23 @@
+import qs from 'query-string';
+import jwtUtil from './jwt';
+
+function isJwtExpired(urlStr) {
+  var jwtStr = _getJwt(urlStr);
+  return jwtUtil.isJwtExpired(jwtStr);
+}
+
+function _getJwt(urlStr) {
+  var query = qs.parse(qs.extract(urlStr));
+  return query['jwt'];
+}
+
+function hasJwt(url) {
+  var jwt = _getJwt(url);
+  return (jwt && _getJwt(url).length !== 0);
+
+}
+
+export default {
+  hasJwt,
+  isJwtExpired
+}