@atlassian/atlassian-connect-js 5.3.190

package/src/host/actions/analytics_action.js

@@ -0,0 +1,35 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  trackDeprecatedMethodUsed(methodUsed, extension) {
+    EventDispatcher.dispatch('analytics-deprecated-method-used', {methodUsed, extension});
+  },
+  trackIframeBridgeStart(extension) {
+    EventDispatcher.dispatch('iframe-bridge-start', {extension});
+  },
+  trackExternalEvent(name, values){
+    EventDispatcher.dispatch('analytics-external-event-track', {
+      eventName: name,
+      values: values
+    });
+  },
+  trackContentResolverEvent(success, extra) {
+    EventDispatcher.dispatch('analytics-content-resolver-track', {
+      success: success,
+      extra: extra
+    })
+  },
+  trackIframePerformanceMetrics(metrics, extension) {
+    if(metrics && Object.getOwnPropertyNames(metrics).length > 0) {
+      EventDispatcher.dispatch('analytics-iframe-performance', {metrics, extension});
+    }
+  },
+  trackWebVitals(metrics, extension) {
+    if (metrics && Object.keys(metrics).length > 0) {
+      EventDispatcher.dispatch('analytics-web-vitals', {metrics, extension});
+    }
+  },
+  trackIframeClick(data) {
+    EventDispatcher.dispatch('analytics-track-iframe-clicked', data)
+  }
+};

package/src/host/actions/button_actions.js

@@ -0,0 +1,21 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  clicked: ($el) => {
+    EventDispatcher.dispatch('button-clicked', {
+      $el
+    });
+  },
+  toggle: ($el, disabled) => {
+    EventDispatcher.dispatch('button-toggle', {
+      $el,
+      disabled
+    });
+  },
+  toggleVisibility: ($el, hidden) => {
+    EventDispatcher.dispatch('button-toggle-visibility', {
+      $el,
+      hidden
+    });
+  }
+};

package/src/host/actions/dialog_actions.js

@@ -0,0 +1,27 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  close: (data) => {
+    EventDispatcher.dispatch('dialog-close', {
+      dialog: data.dialog,
+      extension: data.extension,
+      customData: data.customData
+    });
+  },
+  closeActive: (data) => {
+    EventDispatcher.dispatch('dialog-close-active', data);
+  },
+  clickButton: (identifier, $el, extension) => {
+    EventDispatcher.dispatch('dialog-button-click', {
+      identifier,
+      $el,
+      extension
+    });
+  },
+  toggleButton: (data) => {
+    EventDispatcher.dispatch('dialog-button-toggle', data);
+  },
+  toggleButtonVisibility: (data) => {
+    EventDispatcher.dispatch('dialog-button-toggle-visibility', data);
+  }
+};

package/src/host/actions/dialog_extension_actions.js

@@ -0,0 +1,25 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  open: (extension, options) => {
+    EventDispatcher.dispatch('dialog-extension-open', {
+      extension: extension,
+      options: options
+    });
+  },
+  close: () => {
+    EventDispatcher.dispatch('dialog-close-active', {});
+  },
+  addUserButton: (options, extension) => {
+    EventDispatcher.dispatch('dialog-button-add', {
+      button: {
+        text: options.text,
+        identifier: options.identifier,
+        data: {
+          userButton: true
+        }
+      },
+      extension: extension
+    });
+  }
+};

package/src/host/actions/dom_event_actions.js

@@ -0,0 +1,32 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import SimpleXDM from 'simple-xdm/host';
+import util from '../util';
+
+export default {
+  registerKeyEvent: function(data){
+    SimpleXDM.registerKeyListener(data.extension_id, data.key, data.modifiers, data.callback);
+    EventDispatcher.dispatch('dom-event-register', data);
+  },
+  unregisterKeyEvent: function(data){
+    SimpleXDM.unregisterKeyListener(data.extension_id, data.key, data.modifiers, data.callback);
+    EventDispatcher.dispatch('dom-event-unregister', data);
+  },
+  registerWindowKeyEvent: function(data){
+    window.addEventListener('keydown', (event) => {
+      if (event.keyCode === data.keyCode) {
+        data.callback();
+      }
+    });
+  },
+  registerClickHandler: function(handleIframeClick) {
+    SimpleXDM.registerClickHandler(function (data) {
+      var iframe = document.getElementById(data.extension_id);
+      if (iframe) {
+        handleIframeClick(iframe, data);
+      }
+    });
+  },
+  unregisterClickHandler: function() {
+    SimpleXDM.unregisterClickHandler();
+  }
+};

package/src/host/actions/dropdown_actions.js

@@ -0,0 +1,12 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  // called on action click
+  itemSelected: function (dropdown_id, item, extension) {
+    EventDispatcher.dispatch('dropdown-item-selected', {
+      id: dropdown_id,
+      item,
+      extension
+    });
+  }
+};

package/src/host/actions/env_actions.js

@@ -0,0 +1,57 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import util from '../util';
+import IframeComponent from '../components/iframe';
+import $ from '../dollar';
+import getBooleanFeatureFlag from '../utils/feature-flag';
+
+EventDispatcher.register('iframe-resize', function(data) {
+  IframeComponent.resize(data.width, data.height, data.$el);
+});
+
+EventDispatcher.register('iframe-size-to-parent', function(data) {
+  var height;
+  var $el = util.getIframeByExtensionId(data.extensionId);
+  height = ($(window).height() - $el.offset().top - 1) + 'px'; //1px comes from margin given by full-size-general-page
+  // When in unit test (env_module_spec.js), $el.get(0).name is an empty string, breaking the test. Thus doing this check.
+  if($el.get(0).name.length > 0 && JSON.parse($el.get(0).name).options.moduleType === 'jiraProjectPages') {
+    height = '100%';
+  }
+  EventDispatcher.dispatch('iframe-resize', {
+    width: '100%',
+    height: height,
+    $el
+  });
+});
+
+EventDispatcher.register('hide-footer', function(hideFooter) {
+  if (hideFooter) {
+    $('#footer').css({ display: 'none' });
+  }
+});
+
+
+window.addEventListener('resize', function(e){
+  EventDispatcher.dispatch('host-window-resize', e);
+}, true);
+
+export default {
+  iframeResize: function(width, height, context) {
+    var $el;
+    if (context.extension_id) {
+      $el = util.getIframeByExtensionId(context.extension_id);
+    } else {
+      $el = context;
+    }
+
+    EventDispatcher.dispatch('iframe-resize', { width, height, $el, extension: context.extension });
+  },
+  sizeToParent: function(extensionId, hideFooter) {
+    EventDispatcher.dispatch('iframe-size-to-parent', {
+      hideFooter: hideFooter,
+      extensionId: extensionId
+    });
+  },
+  hideFooter: function(hideFooter) {
+    EventDispatcher.dispatch('hide-footer', hideFooter);
+  }
+};

package/src/host/actions/event_actions.js

@@ -0,0 +1,33 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import SimpleXDM from 'simple-xdm/host';
+import SimpleXDMUtil from 'simple-xdm/src/common/util';
+
+export default {
+  targetSpecNoDialogs: (registration) => registration?.extension?.options?.moduleType !== 'dialogs',
+  broadcast: function(type, targetSpec, event){
+    SimpleXDM.dispatch(type, targetSpec, event);
+    EventDispatcher.dispatch('event-dispatch', {
+      type: type,
+      targetSpec: targetSpec,
+      event: event
+    });
+  },
+
+  broadcastPublic: function(type, event, sender){
+    EventDispatcher.dispatch('event-public-dispatch', {
+      type,
+      event,
+      sender
+    });
+
+    const { contextJwt, url, ...filteredOptions } = sender.options || {};
+    SimpleXDM.dispatch(type, {}, {
+      sender: {
+        addonKey: sender.addon_key,
+        key: sender.key,
+        options: SimpleXDMUtil.sanitizeStructuredClone(filteredOptions)
+      },
+      event: event
+    });
+  }
+};

package/src/host/actions/flag_actions.js

@@ -0,0 +1,22 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  // called on action click
+  actionInvoked: function (actionId, flagId) {
+    EventDispatcher.dispatch('flag-action-invoked', {
+      id: flagId,
+      actionId: actionId
+    });
+  },
+  open: function(flagId){
+    EventDispatcher.dispatch('flag-open', {id: flagId});
+  },
+  //called to close a flag
+  close: function(flagId){
+    EventDispatcher.dispatch('flag-close', {id: flagId});
+  },
+  //called by AUI when closed
+  closed: function(flagId){
+    EventDispatcher.dispatch('flag-closed', {id: flagId});
+  }
+};

package/src/host/actions/iframe_actions.js

@@ -0,0 +1,27 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import simpleXDM from 'simple-xdm/host';
+
+export default {
+  notifyIframeCreated: function($el, extension) {
+    EventDispatcher.dispatch('iframe-create', {$el, extension});
+  },
+
+  notifyBridgeEstablished: function($el, extension){
+    EventDispatcher.dispatch('iframe-bridge-established', {$el, extension});
+  },
+
+  notifyIframeDestroyed: function(filter){
+    if(typeof filter === 'string') {
+      filter = {id: filter};
+    }
+    var extensions = simpleXDM.getExtensions(filter);
+    extensions.forEach((extension) => {
+      EventDispatcher.dispatch('iframe-destroyed', {extension});
+      simpleXDM.unregisterExtension({id: extension.extension_id});
+    }, this);
+  },
+
+  notifyUnloaded: function($el, extension){
+    EventDispatcher.dispatch('iframe-unload', {$el, extension});
+  }
+};

package/src/host/actions/inline_dialog_actions.js

@@ -0,0 +1,26 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  hide: function($el){
+    EventDispatcher.dispatch('inline-dialog-hide', {
+      $el: $el
+    });
+  },
+  refresh: function($el){
+    EventDispatcher.dispatch('inline-dialog-refresh', {$el});
+  },
+  hideTriggered: function(extension_id, $el){
+    EventDispatcher.dispatch('inline-dialog-hidden', {extension_id, $el});
+  },
+  close: function(){
+    EventDispatcher.dispatch('inline-dialog-close', {
+    });
+  },
+  created: function(data) {
+    EventDispatcher.dispatch('inline-dialog-opened', {
+      $el: data.$el,
+      trigger: data.trigger,
+      extension: data.extension
+    });
+  }
+};

package/src/host/actions/inline_dialog_webitem_actions.js

@@ -0,0 +1,10 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  addExtension: function(data){
+    EventDispatcher.dispatch('inline-dialog-extension', {
+      $el: data.$el,
+      extension: data.extension
+    });
+  }
+};

package/src/host/actions/jwt_actions.js

@@ -0,0 +1,51 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import Util from '../util';
+
+export default {
+  registerContentResolver: function(data) {
+    EventDispatcher.dispatch('content-resolver-register-by-extension', data);
+  },
+  requestRefreshUrl: function(data){
+    if(!data.resolver) {
+      throw Error('ACJS: No content resolver supplied');
+    }
+    var promise = data.resolver.call(null, Util.extend({classifier: 'json'}, data.extension));
+    promise.fail(function(promiseData, error) {
+      EventDispatcher.dispatch('jwt-url-refreshed-failed', {
+        extension: data.extension,
+        $container: data.$container,
+        errorText: error.text,
+        errorTraceId: error.traceId
+      });
+    });
+    promise.done(function (promiseData) {
+      var newExtensionConfiguration = {};
+      if(typeof promiseData === 'object') {
+        newExtensionConfiguration = promiseData;
+      } else if(typeof promiseData === 'string') {
+        try{
+          newExtensionConfiguration = JSON.parse(promiseData);
+        } catch(e){
+          console.error('ACJS: invalid response from content resolver');
+        }
+      }
+      data.extension.url = newExtensionConfiguration.url;
+      Util.extend(data.extension.options, newExtensionConfiguration.options);
+      EventDispatcher.dispatch('jwt-url-refreshed', {
+        extension: data.extension,
+        $container: data.$container,
+        url: data.extension.url
+      });
+    });
+    EventDispatcher.dispatch('jwt-url-refresh-request', {data});
+  },
+
+  setClockSkew: function(skew) {
+    if(typeof skew === 'number') {
+      EventDispatcher.dispatch('jwt-skew-set', {skew});
+    } else {
+      console.error('ACJS: invalid JWT clock skew set');
+    }
+  }
+
+};

package/src/host/actions/loading_indicator_actions.js

@@ -0,0 +1,10 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  timeout($el, extension) {
+    EventDispatcher.dispatch('iframe-bridge-timeout', {$el, extension});
+  },
+  cancelled($el, extension) {
+    EventDispatcher.dispatch('iframe-bridge-cancelled', {$el, extension});
+  }
+};

package/src/host/actions/module_actions.js

@@ -0,0 +1,14 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+
+export default {
+  defineCustomModule: function(name, methods){
+    var data = {};
+    if(!methods){
+      data.methods = name;
+    } else {
+      data.methods = methods;
+      data.name = name;
+    }
+    EventDispatcher.dispatch('module-define-custom', data);
+  }
+}

package/src/host/actions/webitem_actions.js

@@ -0,0 +1,29 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import WebItemComponent from '../components/webitem';
+
+/**
+ * @typedef {{$target: JQuery, eventType: 'click' | 'mouseenter', extension: Object}} WebItemInvokedEventData
+ */
+export default {
+  addWebItem: (potentialWebItem) => {
+    let webitem;
+    let existing = WebItemComponent.getWebItemsBySelector(potentialWebItem.selector);
+
+    if(existing) {
+      return false;
+    } else {
+      webitem = WebItemComponent.setWebItem(potentialWebItem);
+      EventDispatcher.dispatch('webitem-added', {webitem});
+    }
+
+  },
+
+  /**
+   * @param {boolean} isInlineDialog
+   * @param {WebItemInvokedEventData} data
+   */
+  webitemInvoked: (isInlineDialog, data) => {
+    const eventName = isInlineDialog ? 'inline-dialog' : 'dialog'
+    EventDispatcher.dispatch('webitem-invoked:' + eventName, data);
+  }
+};

package/src/host/components/button.js

@@ -0,0 +1,112 @@
+import EventDispatcher from '../dispatchers/event_dispatcher';
+import $ from '../dollar';
+import ButtonActions from '../actions/button_actions';
+import ButtonUtils from '../utils/button';
+
+const BUTTON_TYPES = ['primary', 'link', 'secondary'];
+var buttonId = 0;
+
+class Button {
+  constructor() {
+    this.AP_BUTTON_CLASS = 'ap-aui-button';
+  }
+
+  setType($button, type){
+    if(type && BUTTON_TYPES.indexOf(type) >= 0) {
+      $button.addClass('aui-button-' + type);
+    }
+    return $button;
+  }
+
+  setDisabled($button, disabled) {
+    if(typeof disabled !== 'undefined' && !$button.data('immutable')) {
+      $button.attr('aria-disabled', disabled);
+    }
+    return $button;
+  }
+
+  setHidden($button, hidden) {
+    if(typeof hidden !== 'undefined' && !$button.data('immutable')) {
+      $button.toggle(!hidden);
+    }
+    return $button;
+  }
+
+  _setId($button, id) {
+    if(!id) {
+      id = 'ap-button-' + buttonId;
+      buttonId++;
+    }
+    $button.attr('id', id);
+    return $button;
+  }
+
+  _additionalClasses($button, classes) {
+    if(classes) {
+      if(typeof classes !== 'string') {
+        classes = classes.join(' ');
+      }
+      $button.addClass(classes);
+    }
+    return $button;
+  }
+
+  getName($button) {
+    return $($button).data('name');
+  }
+
+  getText($button) {
+    return $($button).text();
+  }
+
+  getIdentifier($button) {
+    return $($button).data('identifier');
+  }
+
+  isVisible($button) {
+    return $($button).is(':visible');
+  }
+
+  isEnabled($button) {
+    return !($($button).attr('aria-disabled') === 'true');
+  }
+
+  render (options) {
+    var $button = $('<button />');
+    options = options || {};
+    $button.addClass('aui-button ' + this.AP_BUTTON_CLASS);
+    $button.text(options.text);
+    $button.data(options.data);
+    $button.data({
+      name: options.name || options.identifier,
+      identifier: options.identifier || ButtonUtils.randomIdentifier(),
+      immutable: options.immutable || false
+    });
+    this._additionalClasses($button, options.additionalClasses);
+    this.setType($button, options.type);
+    this.setDisabled($button, options.disabled || false);
+    this._setId($button, options.id);
+    return $button;
+  }
+}
+
+var ButtonComponent = new Button();
+// register 1 button listener globally on dom load
+$(function(){
+  $('body').on('click', '.' + ButtonComponent.AP_BUTTON_CLASS, function(e){
+    var $button = $(e.target).closest('.' + ButtonComponent.AP_BUTTON_CLASS);
+    if ($button.attr('aria-disabled') !== 'true') {
+      ButtonActions.clicked($button);
+    }
+  });
+});
+
+EventDispatcher.register('button-toggle', (data) => {
+  ButtonComponent.setDisabled(data.$el, data.disabled);
+});
+
+EventDispatcher.register('button-toggle-visibility', (data) => {
+  ButtonComponent.setHidden(data.$el, data.hidden);
+});
+
+export default ButtonComponent;