@gridsuite/commons-ui 0.46.0 → 0.47.0

package/dist/utils/AuthService.js

@@ -0,0 +1,336 @@
+import { Log, UserManager } from "oidc-client";
+import { UserManagerMock } from "./UserManagerMock.js";
+import { setShowAuthenticationRouterLogin, setLoggedUser, setLogoutError, setUnauthorizedUserInfo, setUserValidationError, resetAuthenticationRouterError, setSignInCallbackError } from "./actions.js";
+import jwtDecode from "jwt-decode";
+window.OIDCLog = Log;
+const hackAuthorityKey = "oidc.hack.authority";
+const oidcHackReloadedKey = "gridsuite-oidc-hack-reloaded";
+const pathKey = "powsybl-gridsuite-current-path";
+function isIssuerErrorForCodeFlow(error) {
+  return error.message.includes("Invalid issuer in token");
+}
+function extractIssuerToSessionStorage(error) {
+  const issuer = error.message.split(" ").pop();
+  sessionStorage.setItem(hackAuthorityKey, issuer);
+}
+function reload() {
+  if (!sessionStorage.getItem(oidcHackReloadedKey)) {
+    sessionStorage.setItem(oidcHackReloadedKey, true);
+    console.log("Hack oidc, reload page to make login work");
+    window.location.reload();
+  }
+}
+function reloadTimerOnExpiresIn(user, userManager, expiresIn) {
+  user.expires_in = expiresIn;
+  userManager.storeUser(user).then(() => {
+    userManager.getUser();
+  });
+}
+function handleSigninSilent(dispatch, userManager) {
+  userManager.getUser().then((user) => {
+    if (user == null || getIdTokenExpiresIn(user) < 0) {
+      return userManager.signinSilent().catch((error) => {
+        dispatch(setShowAuthenticationRouterLogin(true));
+        const errorIssuerCodeFlow = isIssuerErrorForCodeFlow(error);
+        const errorIssuerImplicitFlow = error.message === "authority mismatch on settings vs. signin state";
+        if (errorIssuerCodeFlow) {
+          extractIssuerToSessionStorage(error);
+        }
+        if (errorIssuerCodeFlow || errorIssuerImplicitFlow) {
+          reload();
+        }
+      });
+    }
+  });
+}
+function initializeAuthenticationDev(dispatch, isSilentRenew, validateUser, isSigninCallback) {
+  let userManager = new UserManagerMock({});
+  if (!isSilentRenew) {
+    handleUser(dispatch, userManager, validateUser);
+    if (!isSigninCallback) {
+      handleSigninSilent(dispatch, userManager);
+    }
+  }
+  return Promise.resolve(userManager);
+}
+const accessTokenExpiringNotificationTime = 60;
+function initializeAuthenticationProd(dispatch, isSilentRenew, idpSettings, validateUser, authorizationCodeFlowEnabled, isSigninCallback) {
+  return idpSettings.then((r) => r.json()).then((idpSettings2) => {
+    const regextoken = /id_token=[^&]*/;
+    const regexstate = /state=[^&]*/;
+    const regexexpires = /expires_in=[^&]*/;
+    let authority;
+    if (window.location.hash) {
+      const matched_id_token = window.location.hash.match(regextoken);
+      const matched_state = window.location.hash.match(regexstate);
+      if (matched_id_token != null && matched_state != null) {
+        const id_token = matched_id_token[0].split("=")[1];
+        const state = matched_state[0].split("=")[1];
+        const strState = localStorage.getItem("oidc." + state);
+        if (strState != null) {
+          const decoded = jwtDecode(id_token);
+          authority = decoded.iss;
+          const storedState = JSON.parse(strState);
+          console.debug(
+            "Replacing authority in storedState. Before: ",
+            storedState.authority,
+            "after: ",
+            authority
+          );
+          storedState.authority = authority;
+          localStorage.setItem(
+            "oidc." + state,
+            JSON.stringify(storedState)
+          );
+          sessionStorage.setItem(hackAuthorityKey, authority);
+          const matched_expires = window.location.hash.match(regexexpires);
+          if (matched_expires != null) {
+            const expires_in = parseInt(
+              matched_expires[0].split("=")[1]
+            );
+            window.location.hash = window.location.hash.replace(
+              matched_expires[0],
+              "expires_in=" + computeMinExpiresIn(
+                expires_in,
+                id_token,
+                idpSettings2.maxExpiresIn
+              )
+            );
+          }
+        }
+      }
+    }
+    authority = authority || sessionStorage.getItem(hackAuthorityKey) || idpSettings2.authority;
+    const responseSettings = authorizationCodeFlowEnabled ? { response_type: "code" } : {
+      response_type: "id_token token",
+      response_mode: "fragment"
+    };
+    const settings = {
+      authority,
+      client_id: idpSettings2.client_id,
+      redirect_uri: idpSettings2.redirect_uri,
+      post_logout_redirect_uri: idpSettings2.post_logout_redirect_uri,
+      silent_redirect_uri: idpSettings2.silent_redirect_uri,
+      scope: idpSettings2.scope,
+      automaticSilentRenew: !isSilentRenew,
+      accessTokenExpiringNotificationTime,
+      ...responseSettings
+    };
+    let userManager = new UserManager(settings);
+    userManager.idpSettings = idpSettings2;
+    userManager.authorizationCodeFlowEnabled = authorizationCodeFlowEnabled;
+    if (!isSilentRenew) {
+      handleUser(dispatch, userManager, validateUser);
+      if (!isSigninCallback) {
+        handleSigninSilent(dispatch, userManager);
+      }
+    }
+    return userManager;
+  }).catch((error) => {
+    console.debug("error when importing the idp settings", error);
+    dispatch(setShowAuthenticationRouterLogin(true));
+    throw error;
+  });
+}
+function computeMinExpiresIn(expiresIn, idToken, maxExpiresIn) {
+  const now = parseInt(Date.now() / 1e3);
+  const exp = jwtDecode(idToken).exp;
+  const idTokenExpiresIn = exp - now;
+  let newExpiresIn = expiresIn;
+  let newExpiresInReplaceReason;
+  if (expiresIn === void 0 || idTokenExpiresIn < newExpiresIn) {
+    newExpiresIn = idTokenExpiresIn;
+    newExpiresInReplaceReason = "idtoken.exp is earlier";
+  }
+  if (maxExpiresIn && maxExpiresIn < newExpiresIn) {
+    newExpiresIn = maxExpiresIn;
+    newExpiresInReplaceReason = "idpSettings.maxExpiresIn is smaller";
+  }
+  if (newExpiresInReplaceReason) {
+    console.debug(
+      "Replacing expiresIn in user to " + newExpiresIn + " because " + newExpiresInReplaceReason + ". ",
+      "debug:",
+      "original expires_in: " + expiresIn + ", ",
+      "idTokenExpiresIn: " + idTokenExpiresIn + ", idpSettings maxExpiresIn: " + maxExpiresIn
+    );
+  }
+  return newExpiresIn;
+}
+function login(location, userManagerInstance) {
+  sessionStorage.setItem(pathKey, location.pathname + location.search);
+  return userManagerInstance.signinRedirect().then(() => console.debug("login"));
+}
+function logout(dispatch, userManagerInstance) {
+  sessionStorage.removeItem(hackAuthorityKey);
+  return userManagerInstance.getUser().then((user) => {
+    if (user) {
+      return userManagerInstance.signoutRedirect({
+        extraQueryParams: {
+          TargetResource: userManagerInstance.settings.post_logout_redirect_uri
+        }
+      }).then(() => {
+        console.debug("logged out, window is closing...");
+      }).catch((e) => {
+        var _a;
+        console.log("Error during logout :", e);
+        dispatch(setLoggedUser(null));
+        dispatch(setLogoutError((_a = user == null ? void 0 : user.profile) == null ? void 0 : _a.name, { error: e }));
+      });
+    } else {
+      console.log("Error nobody to logout ");
+    }
+  });
+}
+function getIdTokenExpiresIn(user) {
+  const now = parseInt(Date.now() / 1e3);
+  const exp = jwtDecode(user.id_token).exp;
+  return exp - now;
+}
+function dispatchUser(dispatch, userManagerInstance, validateUser) {
+  return userManagerInstance.getUser().then((user) => {
+    if (user) {
+      if (getIdTokenExpiresIn(user) < 0) {
+        console.debug(
+          "User token is expired and will not be dispatched"
+        );
+        return;
+      }
+      let validateUserPromise = validateUser && validateUser(user) || Promise.resolve(true);
+      return validateUserPromise.then((valid) => {
+        var _a;
+        if (!valid) {
+          console.debug(
+            "User isn't authorized to log in and will not be dispatched"
+          );
+          return dispatch(
+            setUnauthorizedUserInfo((_a = user == null ? void 0 : user.profile) == null ? void 0 : _a.name, {})
+          );
+        }
+        console.debug(
+          "User has been successfully loaded from store."
+        );
+        if (userManagerInstance.authorizationCodeFlowEnabled) {
+          reloadTimerOnExpiresIn(
+            user,
+            userManagerInstance,
+            computeMinExpiresIn(
+              user.expires_in,
+              user.id_token,
+              userManagerInstance.idpSettings.maxExpiresIn
+            )
+          );
+        }
+        return dispatch(setLoggedUser(user));
+      }).catch((e) => {
+        var _a;
+        console.log("Error in dispatchUser", e);
+        return dispatch(
+          setUserValidationError((_a = user == null ? void 0 : user.profile) == null ? void 0 : _a.name, {
+            error: e
+          })
+        );
+      });
+    } else {
+      console.debug("You are not logged in.");
+    }
+  });
+}
+function getPreLoginPath() {
+  return sessionStorage.getItem(pathKey);
+}
+function navigateToPreLoginPath(navigate) {
+  const previousPath = getPreLoginPath();
+  navigate(previousPath);
+}
+function handleSigninCallback(dispatch, navigate, userManagerInstance) {
+  let reloadAfterNavigate = false;
+  userManagerInstance.signinRedirectCallback().catch(function(e) {
+    if (isIssuerErrorForCodeFlow(e)) {
+      extractIssuerToSessionStorage(e);
+      reloadAfterNavigate = true;
+    } else {
+      throw e;
+    }
+  }).then(function() {
+    dispatch(setSignInCallbackError(null));
+    navigateToPreLoginPath(navigate);
+    if (reloadAfterNavigate) {
+      reload();
+    }
+  }).catch(function(e) {
+    dispatch(setSignInCallbackError(e));
+    console.error(e);
+  });
+}
+function handleSilentRenewCallback(userManagerInstance) {
+  userManagerInstance.signinSilentCallback();
+}
+function handleUser(dispatch, userManager, validateUser) {
+  userManager.events.addUserLoaded((user) => {
+    console.debug("user loaded", user);
+    dispatchUser(dispatch, userManager, validateUser);
+  });
+  userManager.events.addSilentRenewError((error) => {
+    console.debug(error);
+    window.setTimeout(() => {
+      userManager.getUser().then((user) => {
+        if (!user) {
+          console.error(
+            "user is null at silent renew error, it shouldn't happen."
+          );
+        }
+        const idTokenExpiresIn = getIdTokenExpiresIn(user);
+        if (idTokenExpiresIn < 0) {
+          console.log(
+            "Error in silent renew, idtoken expired: " + idTokenExpiresIn + " => Logging out.",
+            error
+          );
+          dispatch(setShowAuthenticationRouterLogin(true));
+          dispatch(resetAuthenticationRouterError());
+          return dispatch(setLoggedUser(null));
+        } else if (userManager.idpSettings.maxExpiresIn) {
+          if (idTokenExpiresIn < userManager.idpSettings.maxExpiresIn) {
+            console.log(
+              "Error in silent renew, but idtoken ALMOST expiring (expiring in" + idTokenExpiresIn + ") => last chance, next error will logout",
+              "maxExpiresIn = " + userManager.idpSettings.maxExpiresIn,
+              "last renew attempt in " + idTokenExpiresIn - accessTokenExpiringNotificationTime + "seconds",
+              error
+            );
+            reloadTimerOnExpiresIn(
+              user,
+              userManager,
+              idTokenExpiresIn
+            );
+          } else {
+            console.log(
+              "Error in silent renew, but idtoken NOT expiring (expiring in" + idTokenExpiresIn + ") => postponing expiration to" + userManager.idpSettings.maxExpiresIn,
+              error
+            );
+            reloadTimerOnExpiresIn(
+              user,
+              userManager,
+              userManager.idpSettings.maxExpiresIn
+            );
+          }
+        } else {
+          console.log(
+            "Error in silent renew, unsupported configuration: token still valid for " + idTokenExpiresIn + " but maxExpiresIn is not configured:" + userManager.idpSettings.maxExpiresIn,
+            error
+          );
+        }
+      });
+    }, accessTokenExpiringNotificationTime * 1e3);
+  });
+  console.debug("dispatch user");
+  dispatchUser(dispatch, userManager, validateUser);
+}
+export {
+  dispatchUser,
+  getPreLoginPath,
+  handleSigninCallback,
+  handleSilentRenewCallback,
+  initializeAuthenticationDev,
+  initializeAuthenticationProd,
+  login,
+  logout
+};

package/dist/utils/ElementType.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { Settings, Article, NoteAlt, OfflineBolt, LibraryBooksOutlined } from "@mui/icons-material";
+const elementType = {
+  DIRECTORY: "DIRECTORY",
+  STUDY: "STUDY",
+  FILTER: "FILTER",
+  MODIFICATION: "MODIFICATION",
+  CONTINGENCY_LIST: "CONTINGENCY_LIST",
+  VOLTAGE_INIT_PARAMETERS: "VOLTAGE_INIT_PARAMETERS",
+  SECURITY_ANALYSIS_PARAMETERS: "SECURITY_ANALYSIS_PARAMETERS",
+  LOADFLOW_PARAMETERS: "LOADFLOW_PARAMETERS",
+  SENSITIVITY_PARAMETERS: "SENSITIVITY_PARAMETERS"
+};
+function getFileIcon(type, style) {
+  switch (type) {
+    case elementType.STUDY:
+      return /* @__PURE__ */ jsx(LibraryBooksOutlined, { sx: style });
+    case elementType.CONTINGENCY_LIST:
+      return /* @__PURE__ */ jsx(OfflineBolt, { sx: style });
+    case elementType.MODIFICATION:
+      return /* @__PURE__ */ jsx(NoteAlt, { sx: style });
+    case elementType.FILTER:
+      return /* @__PURE__ */ jsx(Article, { sx: style });
+    case elementType.VOLTAGE_INIT_PARAMETERS:
+    case elementType.SECURITY_ANALYSIS_PARAMETERS:
+    case elementType.LOADFLOW_PARAMETERS:
+      return /* @__PURE__ */ jsx(Settings, { sx: style });
+    case elementType.DIRECTORY:
+      return;
+    default:
+      console.warn("unknown type [" + type + "]");
+  }
+}
+export {
+  elementType,
+  getFileIcon
+};

package/dist/utils/EquipmentType.js

@@ -0,0 +1,132 @@
+import { LIGHT_THEME } from "../components/TopBar/TopBar.js";
+const TYPE_TAG_MAX_SIZE = "90px";
+const VL_TAG_MAX_SIZE = "100px";
+const equipmentStyles = {
+  equipmentOption: {
+    display: "flex",
+    gap: "20px",
+    width: "100%",
+    margin: "0px",
+    padding: "0px",
+    alignItems: "center",
+    justifyContent: "space-between"
+  },
+  equipmentTag: (theme) => ({
+    borderRadius: "10px",
+    padding: "4px",
+    fontSize: "x-small",
+    textAlign: "center",
+    color: theme === LIGHT_THEME ? "inherit" : "black"
+  }),
+  equipmentTypeTag: {
+    minWidth: TYPE_TAG_MAX_SIZE,
+    maxWidth: TYPE_TAG_MAX_SIZE,
+    background: "lightblue"
+  },
+  equipmentVlTag: {
+    width: VL_TAG_MAX_SIZE,
+    minWidth: VL_TAG_MAX_SIZE,
+    maxWidth: VL_TAG_MAX_SIZE,
+    background: "lightgray",
+    fontStyle: "italic"
+  },
+  result: {
+    width: "100%",
+    padding: "2px"
+  }
+};
+const EQUIPMENT_TYPE = {
+  SUBSTATION: {
+    name: "SUBSTATION",
+    tagLabel: "equipment_search/substationTag"
+  },
+  VOLTAGE_LEVEL: {
+    name: "VOLTAGE_LEVEL",
+    tagLabel: "equipment_search/voltageLevelTag"
+  },
+  LINE: {
+    name: "LINE",
+    tagLabel: "equipment_search/lineTag"
+  },
+  TWO_WINDINGS_TRANSFORMER: {
+    name: "TWO_WINDINGS_TRANSFORMER",
+    tagLabel: "equipment_search/2wtTag"
+  },
+  THREE_WINDINGS_TRANSFORMER: {
+    name: "THREE_WINDINGS_TRANSFORMER",
+    tagLabel: "equipment_search/3wtTag"
+  },
+  HVDC_LINE: {
+    name: "HVDC_LINE",
+    tagLabel: "equipment_search/hvdcLineTag"
+  },
+  GENERATOR: {
+    name: "GENERATOR",
+    tagLabel: "equipment_search/generatorTag"
+  },
+  BATTERY: {
+    name: "BATTERY",
+    tagLabel: "equipment_search/batteryTag"
+  },
+  LOAD: {
+    name: "LOAD",
+    tagLabel: "equipment_search/loadTag"
+  },
+  SHUNT_COMPENSATOR: {
+    name: "SHUNT_COMPENSATOR",
+    tagLabel: "equipment_search/shuntTag"
+  },
+  DANGLING_LINE: {
+    name: "DANGLING_LINE",
+    tagLabel: "equipment_search/lineTag"
+  },
+  STATIC_VAR_COMPENSATOR: {
+    name: "STATIC_VAR_COMPENSATOR",
+    tagLabel: "equipment_search/svcTag"
+  },
+  HVDC_CONVERTER_STATION: {
+    name: "HVDC_CONVERTER_STATION",
+    tagLabel: "equipment_search/hvdcStationTag"
+  },
+  BUSBAR_SECTION: {
+    name: "BUSBAR_SECTION",
+    tagLabel: "equipment_search/busbarSectionTag"
+  },
+  BUS: {
+    name: "BUS",
+    tagLabel: "equipment_search/busTag"
+  },
+  SWITCH: {
+    name: "SWITCH",
+    tagLabel: "equipment_search/switchTag"
+  }
+};
+const getEquipmentsInfosForSearchBar = (equipmentsInfos, getNameOrId) => {
+  return equipmentsInfos.flatMap((e) => {
+    let label = getNameOrId(e);
+    return e.type === "SUBSTATION" ? [
+      {
+        label,
+        id: e.id,
+        key: e.id,
+        type: e.type
+      }
+    ] : e.voltageLevels.map((vli) => {
+      return {
+        label,
+        id: e.id,
+        key: e.id + "_" + vli.id,
+        type: e.type,
+        voltageLevelLabel: getNameOrId(vli),
+        voltageLevelId: vli.id
+      };
+    });
+  });
+};
+export {
+  EQUIPMENT_TYPE,
+  TYPE_TAG_MAX_SIZE,
+  VL_TAG_MAX_SIZE,
+  equipmentStyles,
+  getEquipmentsInfosForSearchBar
+};

package/dist/utils/UserManagerMock.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Events {
+  constructor() {
+    __publicField(this, "userLoadedCallbacks", []);
+  }
+  addUserLoaded(callback) {
+    this.userLoadedCallbacks.push(callback);
+  }
+  addSilentRenewError(callback) {
+  }
+}
+class UserManagerMock {
+  constructor(settings) {
+    __publicField(this, "settings");
+    __publicField(this, "events");
+    __publicField(this, "user", {
+      profile: { name: "John Doe", email: "Jhon.Doe@rte-france.com" },
+      id_token: "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImtpZCI6IllNRUxIVDBndmIwbXhvU0RvWWZvbWpxZmpZVSJ9.eyJhdWQiOiI5YzQwMjQ2MS1iMmFiLTQ3NjctOWRiMy02Njg1OWJiMGZjZDAiLCJpc3MiOiJodHRwczovL2xvZ2luLm1pY3Jvc29mdG9ubGluZS5jb20vNzUwMmRhZDUtZDY0Yy00NmM3LTlkNDctYjE2ZjU4MGZjZmE5L3YyLjAiLCJpYXQiOjE1ODUzMzEyNDksIm5iZiI6MTU4NTMzMTI0OSwiZXhwIjoyNTg1MzM1MTQ5LCJhaW8iOiJBV1FBbS84UEFBQUF3Q0xyTDRIUEUvTnVjOU9OdHN0SUV4cVpyMUlqa1FGbXJvUW5EUzJBaksyWnpneUhQTldPdkE3bitveHkvRzgxWElsb1A0TitsQjZINFJteElwakhNYVArTjIyTzVnMUFaR04yc1d6VHA5T3JWMDIvOXhndXJBMjZrdUNXbGg2RSIsImF0X2hhc2giOiJJaWRYdGRHdzVkbjlOZDFQblVvbDh3IiwiaWRwIjoiaHR0cHM6Ly9zdHMud2luZG93cy5uZXQvOTE4ODA0MGQtNmM2Ny00YzViLWIxMTItMzZhMzA0YjY2ZGFkLyIsIm5vbmNlIjoiMjkzZTcxNzhmOWE5NGZlNjg1ZWY3MjdlZTg5MTYxYjEiLCJzdWIiOiJyTnZjWXJMSXJSN25iSDJPQlhoOFkzU05wZEtPc3dfTUNkX3F3NF9vNDRJIiwidGlkIjoiNzUwMmRhZDUtZDY0Yy00NmM3LTlkNDctYjE2ZjU4MGZjZmE5IiwidXRpIjoiUFBYdkw1UWxDMG1oMGp2N3NaNGJBQSIsInZlciI6IjIuMCJ9.dPAh24KTfsqmDaRoBtMLcayAWnDqVtydQ97P1a99dg93JsDu4Jhxju9vlzvjd6Ro5a1RZdrKFKB_pgC2DkQ3wSeYjpdSNyBAlW1_ryq65JkTJVMp33OsM_7SdjaRIiJfPiJ3U9jRBSyj7ofoHCLUjD_Uu-XreKxpMGhFHOQIO72UfXg8TBpsapjkEv9Dyz2UqMa2BQvO5mxKw93LNg5BI6j2a5LhbMEmmRWqfxWGITJ9TWfHjYdFkrXKcmvWZ9D2b4tsw_5NorDxkuzVFhA89M_0ASzOXoj1Yb6LgdkzWXDimssvyyz5Oe4V3gdkAe8Jj7Uwz-9AR-MO2kNkH7ytHA",
+      session_state: "session state",
+      access_token: "eyJ0eXAiOiJKV1QiLCJub25jZSI6InhKWHlQeXVrU1paQ3BOeEcxZUQway1lVDF0YzZtQ01ZVkZKcnBDOTJxc28iLCJhbGciOiJSUzI1NiIsIng1dCI6IllNRUxIVDBndmIwbXhvU0RvWWZvbWpxZmpZVSIsImtpZCI6IllNRUxIVDBndmIwbXhvU0RvWWZvbWpxZmpZVSJ9.eyJhdWQiOiIwMDAwMDAwMy0wMDAwLTAwMDAtYzAwMC0wMDAwMDAwMDAwMDAiLCJpc3MiOiJodHRwczovL3N0cy53aW5kb3dzLm5ldC83NTAyZGFkNS1kNjRjLTQ2YzctOWQ0Ny1iMTZmNTgwZmNmYTkvIiwiaWF0IjoxNTg1MzMxMjQ5LCJuYmYiOjE1ODUzMzEyNDksImV4cCI6MTU4NTMzNTE0OSwiYWNjdCI6MCwiYWNyIjoiMSIsImFpbyI6IkFVUUF1LzhQQUFBQXdwc3RYMlVkY2VDQWx4dU9tVHpIY0R3RlhTWUtYanIvZUNTSi9PdTRqbTJyUVBCUml0U1dWMThmNldCVEdNdnQ5ZGx0Ry9lTXB1VXZqaTN2NCtzanh3PT0iLCJhbHRzZWNpZCI6IjE6bGl2ZS5jb206MDAwMzQwMDExOUZEOTIxMiIsImFtciI6WyJwd2QiXSwiYXBwX2Rpc3BsYXluYW1lIjoic3BhIiwiYXBwaWQiOiI5YzQwMjQ2MS1iMmFiLTQ3NjctOWRiMy02Njg1OWJiMGZjZDAiLCJhcHBpZGFjciI6IjAiLCJlbWFpbCI6ImNoYW1zZWRkaW5lLmJlbmhhbWVkQGVuc2ktdW1hLnRuIiwiZmFtaWx5X25hbWUiOiJCRU5IQU1FRCIsImdpdmVuX25hbWUiOiJDaGFtc2VkZGluZSIsImlkcCI6ImxpdmUuY29tIiwiaXBhZGRyIjoiNzcuMjA0LjE0Ni4xNTkiLCJuYW1lIjoiQ2hhbXNlZGRpbmUgQkVOSEFNRUQiLCJvaWQiOiIzNTIzYmQ3OC0yZjIxLTQ3ZjYtODhlOC1hYWIzYjZmMjdmNjAiLCJwbGF0ZiI6IjE0IiwicHVpZCI6IjEwMDMyMDAwOURFMDg1NkEiLCJzY3AiOiJVc2VyLlJlYWQgcHJvZmlsZSBvcGVuaWQgZW1haWwiLCJzdWIiOiJjVEd5LVlfV3FLR2x1cmRUVDdSUVlfY3FjSDJoVHpEdllZTmotQ3hONXA4IiwidGlkIjoiNzUwMmRhZDUtZDY0Yy00NmM3LTlkNDctYjE2ZjU4MGZjZmE5IiwidW5pcXVlX25hbWUiOiJsaXZlLmNvbSNjaGFtc2VkZGluZS5iZW5oYW1lZEBlbnNpLXVtYS50biIsInV0aSI6IlBQWHZMNVFsQzBtaDBqdjdzWjRiQUEiLCJ2ZXIiOiIxLjAiLCJ4bXNfc3QiOnsic3ViIjoick52Y1lyTElyUjduYkgyT0JYaDhZM1NOcGRLT3N3X01DZF9xdzRfbzQ0SSJ9LCJ4bXNfdGNkdCI6MTU4MjgyMDM1Mn0.W_ccOGW_AGdg37KSMi7LWHtvm3Mw5p1dHjgDIrUaXduKF2iLS4dCaPw7yeo4VjAcOyV6C0h6ABLDCtkwVt8BSDTIIU7DaT8k2bRbMCCq69BmeiYPsbp-yX6ywGCx5DHsnOLqI2oHbBQktA2Nmv9Va651Pbm3OpSPuGPdVimkFCcnisiGlUOej1ZMNwyVT6386O2pERPtxmFUt_D1dKLxBXxBNxLVUG5BG3bI7wMpBOHEUA5CbaBzYXmGrLMXVVbrj9OsF-WQ6aNoqsm9cicX6pJB60lFz1dxLeSgcFO7Zh2K3PFe4FnXCqAvNPadQMz_kJEO9_phlDV85c2MPqeXbA",
+      token_type: "Bearer",
+      scope: "scopes"
+    });
+    this.settings = settings;
+    this.events = new Events();
+  }
+  getUser() {
+    return Promise.resolve(
+      JSON.parse(sessionStorage.getItem("powsybl-gridsuite-mock-user"))
+    );
+  }
+  signinSilent() {
+    console.info("signinSilent..............");
+    const localStorageUser = JSON.parse(
+      localStorage.getItem("powsybl-gridsuite-mock-user")
+    );
+    if (localStorageUser === null) {
+      return Promise.reject(
+        new Error("End-User authentication required")
+      );
+    }
+    sessionStorage.setItem(
+      "powsybl-gridsuite-mock-user",
+      JSON.stringify(localStorageUser)
+    );
+    this.events.userLoadedCallbacks.forEach((c) => c(localStorageUser));
+    return Promise.resolve(localStorageUser);
+  }
+  signinSilentCallback() {
+    console.error(
+      "Unsupported, iframe signinSilentCallback in UserManagerMock (dev mode)"
+    );
+    return Promise.reject();
+  }
+  signinRedirect() {
+    localStorage.setItem(
+      "powsybl-gridsuite-mock-user",
+      JSON.stringify(this.user)
+    );
+    window.location = "./sign-in-callback";
+    return Promise.resolve(null);
+  }
+  signoutRedirect() {
+    sessionStorage.removeItem("powsybl-gridsuite-mock-user");
+    localStorage.removeItem("powsybl-gridsuite-mock-user");
+    window.location = ".";
+    return Promise.resolve(null);
+  }
+  signinRedirectCallback() {
+    sessionStorage.setItem(
+      "powsybl-gridsuite-mock-user",
+      JSON.stringify(this.user)
+    );
+    this.events.userLoadedCallbacks.forEach((c) => c(this.user));
+    return Promise.resolve("");
+  }
+}
+export {
+  UserManagerMock
+};

package/dist/utils/actions.js

@@ -0,0 +1,71 @@
+const USER = "USER";
+function setLoggedUser(user) {
+  return { type: USER, user };
+}
+const SIGNIN_CALLBACK_ERROR = "SIGNIN_CALLBACK_ERROR";
+function setSignInCallbackError(signInCallbackError) {
+  return {
+    type: SIGNIN_CALLBACK_ERROR,
+    signInCallbackError
+  };
+}
+const UNAUTHORIZED_USER_INFO = "UNAUTHORIZED_USER_INFO";
+function setUnauthorizedUserInfo(userName, unauthorizedUserInfo) {
+  return {
+    type: UNAUTHORIZED_USER_INFO,
+    authenticationRouterError: {
+      userName,
+      unauthorizedUserInfo
+    }
+  };
+}
+const LOGOUT_ERROR = "LOGOUT_ERROR";
+function setLogoutError(userName, logoutError) {
+  return {
+    type: LOGOUT_ERROR,
+    authenticationRouterError: {
+      userName,
+      logoutError
+    }
+  };
+}
+const USER_VALIDATION_ERROR = "USER_VALIDATION_ERROR";
+function setUserValidationError(userName, userValidationError) {
+  return {
+    type: USER_VALIDATION_ERROR,
+    authenticationRouterError: {
+      userName,
+      userValidationError
+    }
+  };
+}
+const RESET_AUTHENTICATION_ROUTER_ERROR = "RESET_AUTHENTICATION_ROUTER_ERROR";
+function resetAuthenticationRouterError() {
+  return {
+    type: RESET_AUTHENTICATION_ROUTER_ERROR,
+    authenticationRouterError: null
+  };
+}
+const SHOW_AUTH_INFO_LOGIN = "SHOW_AUTH_INFO_LOGIN";
+function setShowAuthenticationRouterLogin(showAuthenticationRouterLogin) {
+  return {
+    type: SHOW_AUTH_INFO_LOGIN,
+    showAuthenticationRouterLogin
+  };
+}
+export {
+  LOGOUT_ERROR,
+  RESET_AUTHENTICATION_ROUTER_ERROR,
+  SHOW_AUTH_INFO_LOGIN,
+  SIGNIN_CALLBACK_ERROR,
+  UNAUTHORIZED_USER_INFO,
+  USER,
+  USER_VALIDATION_ERROR,
+  resetAuthenticationRouterError,
+  setLoggedUser,
+  setLogoutError,
+  setShowAuthenticationRouterLogin,
+  setSignInCallbackError,
+  setUnauthorizedUserInfo,
+  setUserValidationError
+};

package/dist/utils/algos.js

@@ -0,0 +1,24 @@
+function equalsArray(a, b) {
+  if (b === a) {
+    return true;
+  }
+  if (!b || !a) {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (var i = 0, l = a.length; i < l; i++) {
+    if (a[i] instanceof Array && b[i] instanceof Array) {
+      if (!equalsArray(a[i], b[i])) {
+        return false;
+      }
+    } else if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  equalsArray
+};