function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * SPDX-FileCopyrightText: (c) 2000 Liferay, Inc. https://liferay.com
 * SPDX-License-Identifier: LGPL-2.1-or-later OR LicenseRef-Liferay-DXP-EULA-2.0.0-2023-06
 */
AUI.add('liferay-session', function (A) {
  var Lang = A.Lang;
  var BUFFER_TIME = [];
  var CONFIG = A.config;
  var DOC = CONFIG.doc;
  var MAP_SESSION_STATE_EVENTS = {
    active: 'activated'
  };
  var SRC = {};
  var SRC_EVENT_OBJ = {
    src: SRC
  };
  var TOAST_ID = 'sessionToast';
  var URL_BASE = themeDisplay.getPathMain() + '/portal/';
  var SessionBase = A.Component.create({
    ATTRS: {
      autoExtend: {
        value: false
      },
      redirectOnExpire: {
        value: true
      },
      redirectUrl: {
        value: ''
      },
      sessionLength: {
        getter: '_getLengthInMillis',
        value: 0
      },
      sessionState: {
        value: 'active'
      },
      sessionTimeoutOffset: {
        getter: '_getLengthInMillis',
        value: 0
      },
      timestamp: {
        getter: '_getTimestamp',
        setter: '_setTimestamp',
        value: 0
      },
      warningLength: {
        getter: '_getLengthInMillis',
        setter: '_setWarningLength',
        value: 0
      },
      warningTime: {
        getter: '_getWarningTime',
        value: 0
      }
    },
    EXTENDS: A.Base,
    NAME: 'liferaysession',
    prototype: {
      _afterSessionStateChange: function _afterSessionStateChange(event) {
        var instance = this;
        var details = event.details;
        var newVal = event.newVal;
        var src = null;

        if ('src' in event && details.length) {
          src = details[0];
        }

        instance.fire(MAP_SESSION_STATE_EVENTS[newVal] || newVal, src);
      },
      _defActivatedFn: function _defActivatedFn(event) {
        var instance = this;
        instance.set('timestamp');

        if (event.src == SRC) {
          Liferay.Util.fetch(URL_BASE + 'extend_session').then(function (response) {
            if (response.status === 500) {
              instance.expire();
            }
          });
        }
      },
      _defExpiredFn: function _defExpiredFn(event) {
        var instance = this;
        A.clearInterval(instance._intervalId);
        instance.set('timestamp', 'expired');

        if (event.src === SRC) {
          instance._expireSession();
        }
      },
      _expireSession: function _expireSession() {
        var instance = this;
        Liferay.Util.fetch(URL_BASE + 'expire_session').then(function (response) {
          if (response.ok) {
            Liferay.fire('sessionExpired');

            if (instance.get('redirectOnExpire')) {
              location.href = instance.get('redirectUrl');
            }
          } else {
            A.setTimeout(function () {
              instance._expireSession();
            }, 1000);
          }
        });
      },
      _getLengthInMillis: function _getLengthInMillis(value) {
        return value * 1000;
      },
      _getTimestamp: function _getTimestamp() {
        var instance = this;
        return A.Cookie.get(instance._cookieKey, instance._cookieOptions) || instance._initTimestamp;
      },
      _getWarningTime: function _getWarningTime() {
        var instance = this;
        return instance.get('sessionLength') - instance.get('warningLength');
      },
      _initEvents: function _initEvents() {
        var instance = this;
        instance.publish('activated', {
          defaultFn: A.bind('_defActivatedFn', instance)
        });
        instance.publish('expired', {
          defaultFn: A.bind('_defExpiredFn', instance)
        });
        instance.publish('warned');
        instance._eventHandlers = [instance.on('sessionStateChange', instance._onSessionStateChange), instance.after('sessionStateChange', instance._afterSessionStateChange), A.on('io:complete', function (transactionId, response, args) {
          if (!args || args && args.sessionExtend || !Lang.isBoolean(args.sessionExtend)) {
            instance.resetInterval();
          }
        }), Liferay.once('screenLoad', function () {
          instance.destroy();
        })];
      },
      _onSessionStateChange: function _onSessionStateChange(event) {
        var instance = this;
        var newVal = event.newVal;
        var prevVal = event.prevVal;

        if (prevVal == 'expired' && prevVal != newVal) {
          event.preventDefault();
        } else if (prevVal == 'active' && prevVal == newVal) {
          instance._afterSessionStateChange(event);
        }
      },
      _setTimestamp: function _setTimestamp(value) {
        var instance = this;
        value = String(value || Date.now());
        instance._initTimestamp = value;

        if (navigator.cookieEnabled) {
          A.Cookie.set(instance._cookieKey, value, instance._cookieOptions);
        }
      },
      _setWarningLength: function _setWarningLength(value) {
        var instance = this;
        return Math.min(instance.get('sessionLength'), value);
      },
      _startTimer: function _startTimer() {
        var instance = this;
        var sessionLength = instance.get('sessionLength');
        var sessionTimeoutOffset = instance.get('sessionTimeoutOffset');
        var warningTime = instance.get('warningTime');
        var registered = instance._registered;
        var interval = 1000;
        instance._intervalId = A.setInterval(function () {
          var sessionState = instance.get('sessionState');
          var timeOffset;
          var timestamp = instance.get('timestamp');
          var elapsed = sessionLength;

          if (Lang.toInt(timestamp)) {
            timeOffset = Math.floor((Date.now() - timestamp) / 1000) * 1000;
            elapsed = timeOffset;

            if (instance._initTimestamp !== timestamp) {
              instance.set('timestamp', timestamp);

              if (sessionState != 'active') {
                instance.set('sessionState', 'active', SRC_EVENT_OBJ);
              }
            }
          } else {
            timestamp = 'expired';
          }

          var extend = instance.get('autoExtend');
          var expirationMoment = false;
          var warningMoment = false;
          var hasExpired = elapsed >= sessionLength;
          var hasExpiredTimeoutOffset = elapsed >= sessionLength - sessionTimeoutOffset;
          var hasWarned = elapsed >= warningTime;

          if (hasExpiredTimeoutOffset || hasWarned) {
            if (timestamp == 'expired') {
              expirationMoment = true;
              extend = false;
              hasExpired = true;
              hasExpiredTimeoutOffset = true;
            }

            if (hasExpiredTimeoutOffset && sessionState != 'expired') {
              if (extend && !hasExpired) {
                expirationMoment = false;
                hasExpired = false;
                hasExpiredTimeoutOffset = false;
                hasWarned = false;
                warningMoment = false;
                instance.extend();
              } else {
                instance.expire();
                expirationMoment = true;
              }
            } else if (hasWarned && !hasExpiredTimeoutOffset && !extend && sessionState != 'warned') {
              instance.warn();
              warningMoment = true;
            }
          }

          for (var i in registered) {
            registered[i](elapsed, interval, hasWarned, hasExpired, hasExpiredTimeoutOffset, warningMoment, expirationMoment);
          }
        }, interval);
      },
      _stopTimer: function _stopTimer() {
        var instance = this;
        A.clearInterval(instance._intervalId);
      },
      destructor: function destructor() {
        var instance = this;
        new A.EventHandle(instance._eventHandlers).detach();

        instance._stopTimer();
      },
      expire: function expire() {
        var instance = this;
        instance.set('sessionState', 'expired', SRC_EVENT_OBJ);
      },
      extend: function extend() {
        var instance = this;
        instance.set('sessionState', 'active', SRC_EVENT_OBJ);
      },
      initializer: function initializer() {
        var instance = this;
        instance._cookieKey = 'LFR_SESSION_STATE_' + themeDisplay.getRealUserId();
        instance._cookieOptions = {
          path: '/',
          secure: A.UA.secure
        };
        instance._registered = {};
        instance.set('timestamp');

        instance._initEvents();

        instance._startTimer();
      },
      registerInterval: function registerInterval(fn) {
        var instance = this;
        var fnId;
        var registered = instance._registered;

        if (Lang.isFunction(fn)) {
          fnId = A.stamp(fn);
          registered[fnId] = fn;
        }

        return fnId;
      },
      resetInterval: function resetInterval() {
        var instance = this;

        instance._stopTimer();

        instance._startTimer();
      },
      unregisterInterval: function unregisterInterval(fnId) {
        var instance = this;
        var registered = instance._registered;

        if (Object.prototype.hasOwnProperty.call(registered, fnId)) {
          delete registered[fnId];
        }

        return fnId;
      },
      warn: function warn() {
        var instance = this;
        instance.set('sessionState', 'warned', SRC_EVENT_OBJ);
      }
    }
  });
  SessionBase.SRC = SRC;
  var SessionDisplay = A.Component.create({
    ATTRS: {
      openToast: {
        validator: Lang.isFunction
      },
      pageTitle: {
        value: DOC.title
      }
    },
    EXTENDS: A.Plugin.Base,
    NAME: 'liferaysessiondisplay',
    NS: 'display',
    prototype: {
      _afterDefActivatedFn: function _afterDefActivatedFn() {
        var instance = this;

        instance._uiSetActivated();
      },
      _afterDefExpiredFn: function _afterDefExpiredFn() {
        var instance = this;

        instance._host.unregisterInterval(instance._intervalId);

        instance._uiSetExpired();
      },
      _beforeHostWarned: function _beforeHostWarned() {
        var instance = this;
        var host = instance._host;
        var sessionLength = host.get('sessionLength');
        var timestamp = host.get('timestamp');
        var warningLength = host.get('warningLength');
        var elapsed = sessionLength;

        if (Lang.toInt(timestamp)) {
          elapsed = Math.floor((Date.now() - timestamp) / 1000) * 1000;
        }

        var remainingTime = sessionLength - elapsed;

        if (remainingTime > warningLength) {
          remainingTime = warningLength;
        }

        instance._getBanner();

        var counterTextNode = document.querySelector("#".concat(TOAST_ID, " .countdown-timer"));

        instance._uiSetRemainingTime(remainingTime, counterTextNode);

        instance._intervalId = host.registerInterval(function (elapsed, interval, hasWarned, hasExpired, warningMoment) {
          if (!hasWarned) {
            instance._uiSetActivated();
          } else if (!hasExpired) {
            if (warningMoment) {
              if (remainingTime <= 0) {
                remainingTime = warningLength;
              }
            }

            elapsed = Math.floor((Date.now() - timestamp) / 1000) * 1000;
            remainingTime = sessionLength - elapsed;

            instance._uiSetRemainingTime(remainingTime, counterTextNode);
          }

          remainingTime -= interval;
        });
      },
      _destroyBanner: function _destroyBanner() {
        var instance = this;
        var toast = document.getElementById(TOAST_ID);
        var toastRootElement = toast === null || toast === void 0 ? void 0 : toast.parentElement;
        Liferay.destroyComponent(TOAST_ID);

        if (toastRootElement) {
          toastRootElement.remove();
        }

        instance._banner = false;
      },
      _formatNumber: function _formatNumber(value) {
        return Lang.String.padNumber(Math.floor(value), 2);
      },
      _formatTime: function _formatTime(time) {
        var instance = this;
        time = Number(time);

        if (Lang.isNumber(time) && time > 0) {
          time /= 1000;
          BUFFER_TIME[0] = instance._formatNumber(time / 3600);
          time %= 3600;
          BUFFER_TIME[1] = instance._formatNumber(time / 60);
          time %= 60;
          BUFFER_TIME[2] = instance._formatNumber(time);
          time = BUFFER_TIME.join(':');
        } else {
          time = 0;
        }

        return time;
      },
      _getBanner: function _getBanner() {
        var instance = this;
        var banner = instance._banner;

        if (!banner) {
          var openToast = instance.get('openToast');
          var toastDefaultConfig = {
            onClick: function onClick(_ref) {
              var event = _ref.event;

              if (event.target.classList.contains('alert-link')) {
                instance._host.extend();
              }
            },
            renderData: {
              componentId: TOAST_ID
            },
            toastProps: {
              autoClose: false,
              id: TOAST_ID,
              role: 'alert'
            }
          };
          openToast(_objectSpread({
            message: instance._warningText,
            type: 'warning'
          }, toastDefaultConfig));
          var toastComponent = Liferay.component(TOAST_ID);
          banner = _objectSpread({
            open: function open(props) {
              instance._destroyBanner();

              openToast(_objectSpread(_objectSpread({}, props), toastDefaultConfig));
            }
          }, toastComponent);
          instance._banner = banner;
        }

        return banner;
      },
      _onHostSessionStateChange: function _onHostSessionStateChange(event) {
        var instance = this;

        if (event.newVal == 'warned') {
          instance._beforeHostWarned(event);
        }
      },
      _uiSetActivated: function _uiSetActivated() {
        var instance = this;
        DOC.title = instance.reset('pageTitle').get('pageTitle');

        instance._host.unregisterInterval(instance._intervalId);

        if (instance._banner) {
          instance._destroyBanner();
        }
      },
      _uiSetExpired: function _uiSetExpired() {
        var instance = this;

        var banner = instance._getBanner();

        banner.open({
          message: instance._expiredText,
          title: 'Vaara',
          type: 'danger'
        });
        DOC.title = instance.get('pageTitle');
      },
      _uiSetRemainingTime: function _uiSetRemainingTime(remainingTime, counterTextNode) {
        var instance = this;
        remainingTime = instance._formatTime(remainingTime);

        if (!instance._alertClosed) {
          var alert = counterTextNode.closest('div[role="alert"]'); // Prevent screen reader from rereading alert

          if (alert) {
            alert.removeAttribute('role');
            instance._alert = alert;
          }

          counterTextNode.innerHTML = remainingTime;
        }

        DOC.title = Lang.sub('Istunto\x20vanhenee\x20\x7b0\x7d\x2e', [remainingTime]) + ' | ' + instance.get('pageTitle');
      },
      destructor: function destructor() {
        var instance = this;

        if (instance._banner) {
          instance._destroyBanner();
        }
      },
      initializer: function initializer() {
        var instance = this;
        var host = instance.get('host');

        if (Liferay.Util.getTop() == CONFIG.win) {
          instance._host = host;
          instance._toggleText = {
            hide: 'Piilota',
            show: 'Näytä'
          };
          instance._expiredText = 'Istuntosi\x20on\x20vanhentunut\x20toimettomuuden\x20vuoksi\x2e\x20Tallenna\x20mahdollisesti\x20syöttämäsi\x20tiedot\x20ennen\x20sivun\x20päivittämistä\x2e';
          instance._warningText = 'Toimettomuuden\x20vuoksi\x20istuntosi\x20vanhenee\x20\x7b0\x7d\x2e\x20Jatkaaksesi\x20istuntoasi\x20vielä\x20\x7b1\x7d\x20minuutti\x28a\x29\x2c\x20paina\x20\x3cem\x3eLaajenna\x3c\x2fem\x3e-painiketta\x2e\x20\x7b2\x7d';
          instance._warningText = Lang.sub(instance._warningText, ['<span class="countdown-timer">{0}</span>', host.get('sessionLength') / 60000, '<a class="alert-link" href="javascript:;">' + 'Jatka' + '</a>']);
          host.on('sessionStateChange', instance._onHostSessionStateChange, instance);
          instance.afterHostMethod('_defActivatedFn', instance._afterDefActivatedFn);
          instance.afterHostMethod('_defExpiredFn', instance._afterDefExpiredFn);
        } else {
          host.unplug(instance);
        }
      }
    }
  });
  Liferay.SessionBase = SessionBase;
  Liferay.SessionDisplay = SessionDisplay;
}, '', {
  requires: ['aui-base', 'aui-component', 'aui-timer', 'cookie', 'plugin']
});
//# sourceMappingURL=session.js.map