@equinor/roma-framework 1.0.1 → 2.0.0

package/cypress.mjs

@@ -0,0 +1,806 @@
+import { jsx } from "react/jsx-runtime";
+import { FrameworkProvider } from "@equinor/fusion-framework-react";
+import { ModuleProvider } from "@equinor/fusion-framework-react-module";
+import { QueryClientProvider, QueryClient } from "@tanstack/react-query";
+import { _ as __extends, S as Subscription, l as __spreadArray, m as __read, n as arrRemove, p as isScheduler, O as Observable, h as of, A as Action$2, k as from, B as BehaviorSubject, f as firstValueFrom, I as IntlProvider } from "./router-CD1QGwNJ.mjs";
+import require$$0 from "react-dom";
+import * as React from "react";
+var dateTimestampProvider = {
+  now: function() {
+    return Date.now();
+  },
+  delegate: void 0
+};
+var Action$1 = function(_super) {
+  __extends(Action2, _super);
+  function Action2(scheduler, work) {
+    return _super.call(this) || this;
+  }
+  Action2.prototype.schedule = function(state, delay) {
+    return this;
+  };
+  return Action2;
+}(Subscription);
+var intervalProvider = {
+  setInterval: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearInterval: function(handle) {
+    return clearInterval(handle);
+  },
+  delegate: void 0
+};
+var AsyncAction = function(_super) {
+  __extends(AsyncAction2, _super);
+  function AsyncAction2(scheduler, work) {
+    var _this = _super.call(this, scheduler, work) || this;
+    _this.scheduler = scheduler;
+    _this.work = work;
+    _this.pending = false;
+    return _this;
+  }
+  AsyncAction2.prototype.schedule = function(state, delay) {
+    var _a;
+    if (delay === void 0) {
+      delay = 0;
+    }
+    if (this.closed) {
+      return this;
+    }
+    this.state = state;
+    var id = this.id;
+    var scheduler = this.scheduler;
+    if (id != null) {
+      this.id = this.recycleAsyncId(scheduler, id, delay);
+    }
+    this.pending = true;
+    this.delay = delay;
+    this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
+    return this;
+  };
+  AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay) {
+    if (delay === void 0) {
+      delay = 0;
+    }
+    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+  };
+  AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay) {
+    if (delay === void 0) {
+      delay = 0;
+    }
+    if (delay != null && this.delay === delay && this.pending === false) {
+      return id;
+    }
+    if (id != null) {
+      intervalProvider.clearInterval(id);
+    }
+    return void 0;
+  };
+  AsyncAction2.prototype.execute = function(state, delay) {
+    if (this.closed) {
+      return new Error("executing a cancelled action");
+    }
+    this.pending = false;
+    var error = this._execute(state, delay);
+    if (error) {
+      return error;
+    } else if (this.pending === false && this.id != null) {
+      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+    }
+  };
+  AsyncAction2.prototype._execute = function(state, _delay) {
+    var errored = false;
+    var errorValue;
+    try {
+      this.work(state);
+    } catch (e) {
+      errored = true;
+      errorValue = e ? e : new Error("Scheduled action threw falsy error");
+    }
+    if (errored) {
+      this.unsubscribe();
+      return errorValue;
+    }
+  };
+  AsyncAction2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      var _a = this, id = _a.id, scheduler = _a.scheduler;
+      var actions = scheduler.actions;
+      this.work = this.state = this.scheduler = null;
+      this.pending = false;
+      arrRemove(actions, this);
+      if (id != null) {
+        this.id = this.recycleAsyncId(scheduler, id, null);
+      }
+      this.delay = null;
+      _super.prototype.unsubscribe.call(this);
+    }
+  };
+  return AsyncAction2;
+}(Action$1);
+var Scheduler = function() {
+  function Scheduler2(schedulerActionCtor, now) {
+    if (now === void 0) {
+      now = Scheduler2.now;
+    }
+    this.schedulerActionCtor = schedulerActionCtor;
+    this.now = now;
+  }
+  Scheduler2.prototype.schedule = function(work, delay, state) {
+    if (delay === void 0) {
+      delay = 0;
+    }
+    return new this.schedulerActionCtor(this, work).schedule(state, delay);
+  };
+  Scheduler2.now = dateTimestampProvider.now;
+  return Scheduler2;
+}();
+var AsyncScheduler = function(_super) {
+  __extends(AsyncScheduler2, _super);
+  function AsyncScheduler2(SchedulerAction, now) {
+    if (now === void 0) {
+      now = Scheduler.now;
+    }
+    var _this = _super.call(this, SchedulerAction, now) || this;
+    _this.actions = [];
+    _this._active = false;
+    return _this;
+  }
+  AsyncScheduler2.prototype.flush = function(action) {
+    var actions = this.actions;
+    if (this._active) {
+      actions.push(action);
+      return;
+    }
+    var error;
+    this._active = true;
+    do {
+      if (error = action.execute(action.state, action.delay)) {
+        break;
+      }
+    } while (action = actions.shift());
+    this._active = false;
+    if (error) {
+      while (action = actions.shift()) {
+        action.unsubscribe();
+      }
+      throw error;
+    }
+  };
+  return AsyncScheduler2;
+}(Scheduler);
+var asyncScheduler = new AsyncScheduler(AsyncAction);
+var async = asyncScheduler;
+function isValidDate(value) {
+  return value instanceof Date && !isNaN(value);
+}
+function timer(dueTime, intervalOrScheduler, scheduler) {
+  if (scheduler === void 0) {
+    scheduler = async;
+  }
+  var intervalDuration = -1;
+  {
+    if (isScheduler(intervalOrScheduler)) {
+      scheduler = intervalOrScheduler;
+    } else {
+      intervalDuration = intervalOrScheduler;
+    }
+  }
+  return new Observable(function(subscriber) {
+    var due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
+    if (due < 0) {
+      due = 0;
+    }
+    var n = 0;
+    return scheduler.schedule(function() {
+      if (!subscriber.closed) {
+        subscriber.next(n++);
+        if (0 <= intervalDuration) {
+          this.schedule(void 0, intervalDuration);
+        } else {
+          subscriber.complete();
+        }
+      }
+    }, due);
+  });
+}
+function interval(period, scheduler) {
+  if (scheduler === void 0) {
+    scheduler = asyncScheduler;
+  }
+  return timer(period, period, scheduler);
+}
+var client = {};
+var m = require$$0;
+if (process.env.NODE_ENV === "production") {
+  client.createRoot = m.createRoot;
+  client.hydrateRoot = m.hydrateRoot;
+} else {
+  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  client.createRoot = function(c, o) {
+    i.usingClientEntryPoint = true;
+    try {
+      return m.createRoot(c, o);
+    } finally {
+      i.usingClientEntryPoint = false;
+    }
+  };
+  client.hydrateRoot = function(c, h, o) {
+    i.usingClientEntryPoint = true;
+    try {
+      return m.hydrateRoot(c, h, o);
+    } finally {
+      i.usingClientEntryPoint = false;
+    }
+  };
+}
+function getDisplayName(node, fallbackName = "Unknown") {
+  const type = node === null || node === void 0 ? void 0 : node.type;
+  if (!type) {
+    return fallbackName;
+  }
+  let displayName = null;
+  if (typeof type.displayName === "string") {
+    displayName = type.displayName;
+  }
+  if (!displayName) {
+    displayName = type.name || fallbackName;
+  }
+  const match = displayName.match(/^(.*) \[from (.*)\]$/);
+  if (match) {
+    const componentName = match[1];
+    const moduleName = match[2];
+    if (componentName && moduleName) {
+      if (moduleName === componentName || moduleName.startsWith(`${componentName}.`)) {
+        displayName = componentName;
+      }
+    }
+  }
+  return displayName;
+}
+const ROOT_SELECTOR = "[data-cy-root]";
+const getContainerEl = () => {
+  const el = document.querySelector(ROOT_SELECTOR);
+  if (el) {
+    return el;
+  }
+  throw Error(`No element found that matches selector ${ROOT_SELECTOR}. Please add a root element with data-cy-root attribute to your "component-index.html" file so that Cypress can attach your component to the DOM.`);
+};
+function checkForRemovedStyleOptions(mountingOptions) {
+  for (const key of ["cssFile", "cssFiles", "style", "styles", "stylesheet", "stylesheets"]) {
+    if (mountingOptions[key]) {
+      Cypress.utils.throwErrByPath("mount.removed_style_mounting_options", key);
+    }
+  }
+}
+function setupHooks(optionalCallback) {
+  if (Cypress.testingType !== "component") {
+    return;
+  }
+  Cypress.Commands.overwrite("visit", () => {
+    throw new Error("cy.visit from a component spec is not allowed");
+  });
+  Cypress.Commands.overwrite("session", () => {
+    throw new Error("cy.session from a component spec is not allowed");
+  });
+  Cypress.Commands.overwrite("origin", () => {
+    throw new Error("cy.origin from a component spec is not allowed");
+  });
+  Cypress.on("test:before:after:run:async", () => {
+    optionalCallback === null || optionalCallback === void 0 ? void 0 : optionalCallback();
+  });
+}
+let mountCleanup;
+const makeMountFn = (type, jsx2, options = {}, rerenderKey, internalMountOptions) => {
+  if (!internalMountOptions) {
+    throw Error("internalMountOptions must be provided with `render` and `reactDom` parameters");
+  }
+  if (options.alias) {
+    Cypress.utils.throwErrByPath("mount.alias", options.alias);
+  }
+  checkForRemovedStyleOptions(options);
+  mountCleanup = internalMountOptions.cleanup;
+  return cy.then(() => {
+    var _a, _b, _c;
+    const reactDomToUse = internalMountOptions.reactDom;
+    const el = getContainerEl();
+    if (!el) {
+      throw new Error([
+        `[@cypress/react] 🔥 Hmm, cannot find root element to mount the component. Searched for ${ROOT_SELECTOR}`
+      ].join(" "));
+    }
+    const key = rerenderKey !== null && rerenderKey !== void 0 ? rerenderKey : (
+      // @ts-ignore provide unique key to the the wrapped component to make sure we are rerendering between tests
+      (((_c = (_b = (_a = Cypress === null || Cypress === void 0 ? void 0 : Cypress.mocha) === null || _a === void 0 ? void 0 : _a.getRunner()) === null || _b === void 0 ? void 0 : _b.test) === null || _c === void 0 ? void 0 : _c.title) || "") + Math.random()
+    );
+    const props = {
+      key
+    };
+    const reactComponent = React.createElement(options.strict ? React.StrictMode : React.Fragment, props, jsx2);
+    const userComponent = reactComponent.props.children;
+    internalMountOptions.render(reactComponent, el, reactDomToUse);
+    return cy.wrap(userComponent, { log: false }).then(() => {
+      return cy.wrap({
+        component: userComponent,
+        rerender: (newComponent) => makeMountFn("rerender", newComponent, options, key, internalMountOptions),
+        unmount: () => {
+          Cypress.utils.throwErrByPath("mount.unmount");
+        }
+      }, { log: false });
+    }).wait(0, { log: false }).then(() => {
+      if (options.log !== false) {
+        const componentName = getDisplayName(jsx2);
+        const jsxComponentName = `<${componentName} ... />`;
+        Cypress.log({
+          name: type,
+          type: "parent",
+          message: [jsxComponentName],
+          // @ts-ignore
+          $el: el.children.item(0),
+          consoleProps: () => {
+            return {
+              // @ts-ignore protect the use of jsx functional components use ReactNode
+              props: jsx2 === null || jsx2 === void 0 ? void 0 : jsx2.props,
+              description: type === "mount" ? "Mounts React component" : "Rerenders mounted React component",
+              home: "https://github.com/cypress-io/cypress"
+            };
+          }
+        });
+      }
+    });
+  });
+};
+const makeUnmountFn = (options) => {
+  return cy.then(() => {
+    var _a;
+    const wasUnmounted = mountCleanup === null || mountCleanup === void 0 ? void 0 : mountCleanup();
+    if (wasUnmounted && options.log) {
+      Cypress.log({
+        name: "unmount",
+        type: "parent",
+        message: [(_a = options.boundComponentMessage) !== null && _a !== void 0 ? _a : "Unmounted component"],
+        consoleProps: () => {
+          return {
+            description: "Unmounts React component",
+            parent: getContainerEl().parentNode,
+            home: "https://github.com/cypress-io/cypress"
+          };
+        }
+      });
+    }
+  });
+};
+const preMountCleanup = () => {
+  mountCleanup === null || mountCleanup === void 0 ? void 0 : mountCleanup();
+};
+setupHooks(preMountCleanup);
+const debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+};
+var debug_1 = debug;
+const SEMVER_SPEC_VERSION = "2.0.0";
+const MAX_LENGTH$1 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+9007199254740991;
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+const RELEASE_TYPES = [
+  "major",
+  "premajor",
+  "minor",
+  "preminor",
+  "patch",
+  "prepatch",
+  "prerelease"
+];
+var constants = {
+  MAX_LENGTH: MAX_LENGTH$1,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 1,
+  FLAG_LOOSE: 2
+};
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+  return fn(module, module.exports), module.exports;
+}
+createCommonjsModule(function(module, exports) {
+  const {
+    MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2,
+    MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2,
+    MAX_LENGTH
+  } = constants;
+  exports = module.exports = {};
+  const re = exports.re = [];
+  const safeRe = exports.safeRe = [];
+  const src = exports.src = [];
+  const t = exports.t = {};
+  let R = 0;
+  const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+  const safeRegexReplacements = [
+    ["\\s", 1],
+    ["\\d", MAX_LENGTH],
+    [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2]
+  ];
+  const makeSafeRegex = (value) => {
+    for (const [token, max] of safeRegexReplacements) {
+      value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+    }
+    return value;
+  };
+  const createToken = (name, value, isGlobal) => {
+    const safe = makeSafeRegex(value);
+    const index = R++;
+    debug_1(name, index, value);
+    t[name] = index;
+    src[index] = value;
+    re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+    safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+  };
+  createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+  createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+  createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+  createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+  createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+  createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+  createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+  createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+  createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+  createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+  createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+  createToken("GTLT", "((?:<|>)?=?)");
+  createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+  createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+  createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+  createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+  createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`);
+  createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+  createToken("COERCERTL", src[t.COERCE], true);
+  createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+  createToken("LONETILDE", "(?:~>?)");
+  createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+  exports.tildeTrimReplace = "$1~";
+  createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+  createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("LONECARET", "(?:\\^)");
+  createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+  exports.caretTrimReplace = "$1^";
+  createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+  createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+  createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+  createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+  exports.comparatorTrimReplace = "$1$2$3";
+  createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+  createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+  createToken("STAR", "(<|>)?=?\\s*\\*");
+  createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+});
+let root;
+const cleanup = () => {
+  if (root) {
+    root.unmount();
+    root = null;
+    return true;
+  }
+  return false;
+};
+function mount$1(jsx2, options = {}, rerenderKey) {
+  cleanup();
+  const internalOptions = {
+    reactDom: client,
+    render: (reactComponent, el) => {
+      if (!root) {
+        root = client.createRoot(el);
+      }
+      return root.render(reactComponent);
+    },
+    unmount: internalUnmount,
+    cleanup
+  };
+  return makeMountFn("mount", jsx2, Object.assign({ ReactDom: client }, options), rerenderKey, internalOptions);
+}
+function internalUnmount(options = { log: true }) {
+  return makeUnmountFn(options);
+}
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2["Pop"] = "POP";
+  Action2["Push"] = "PUSH";
+  Action2["Replace"] = "REPLACE";
+  return Action2;
+})(Action || {});
+class RomaMockedServiceDiscovery {
+  constructor() {
+    this.environment = {
+      type: "",
+      clientId: "",
+      services: []
+    };
+    this.configureClient = cy.stub().as("configureClient");
+    this.createClient = cy.stub().as("createClient.sd");
+  }
+  resolveService(key) {
+    return Promise.resolve({
+      name: "mocked_service_name",
+      key: "mocked_service_key",
+      url: "mocked_service_url",
+      uri: "mocked_service_url",
+      version: "mocked_service_version",
+      environment: "mocked_service_environment",
+      defaultScopes: []
+    });
+  }
+  async resolveServices() {
+    return this.environment.services;
+  }
+}
+const _logger = {
+  get: (obj, property) => cy.log
+};
+const logger = new Proxy({}, _logger);
+class RomaMockedAuthModule {
+  constructor() {
+    this.defaultAccount = {
+      homeAccountId: "mocked_home_account_id",
+      environment: "mocked_environment",
+      tenantId: "mocked_tenant_id",
+      username: "mocked_username",
+      localAccountId: "mocked_local_account_id",
+      name: "Mocked User"
+    };
+    this.defaultClient = {
+      acquireToken: (req) => Promise.resolve({
+        authority: "https://login.microsoftonline.com/mock",
+        uniqueId: "mocked_unique_id",
+        tenantId: "mocked_tenant_id",
+        scopes: req.scopes || [],
+        account: this.defaultAccount,
+        idToken: "mocked_id_token",
+        idTokenClaims: {},
+        accessToken: "mocked_access_token",
+        fromCache: false,
+        expiresOn: new Date(Date.now() + 3600 * 1e3),
+        // 1 hour from now
+        tokenType: "Bearer",
+        correlationId: "mocked_correlation_id"
+      }),
+      handleRedirectPromise: () => Promise.resolve(null),
+      login: () => Promise.resolve(),
+      account: {
+        homeAccountId: "mocked_home_account_id",
+        environment: "mocked_environment",
+        tenantId: "mocked_tenant_id",
+        username: "mocked_username",
+        localAccountId: "mocked_local_account_id",
+        name: "Mocked User"
+      },
+      setLogger: cy.stub().as("setLogger"),
+      getLogger: () => logger,
+      requestOrigin: ""
+    };
+    this.defaultConfig = {
+      tenantId: "mocked_tenant_id",
+      clientId: "mocked_client_id",
+      redirectUri: "https://mocked.redirect.uri",
+      config: {}
+    };
+  }
+  acquireAccessToken(req) {
+    return Promise.resolve(
+      "part1." + window.btoa('{"roles": ["role1", "role2", "TRADE_ASSISTANCE_READ"]}') + ".part3"
+    );
+  }
+  acquireToken(req) {
+    return Promise.resolve({
+      authority: "https://login.microsoftonline.com/mock",
+      uniqueId: "mocked_unique_id",
+      tenantId: "mocked_tenant_id",
+      scopes: req.scopes || [],
+      account: this.defaultAccount || null,
+      idToken: "mocked_id_token",
+      idTokenClaims: {},
+      accessToken: "mocked_access_token",
+      fromCache: false,
+      expiresOn: new Date(Date.now() + 3600 * 1e3),
+      // 1 hour from now
+      tokenType: "Bearer",
+      correlationId: "mocked_correlation_id"
+    });
+  }
+  createClient(name) {
+    return this.defaultClient;
+  }
+  getClient(name) {
+    return this.createClient(name);
+  }
+  handleRedirect() {
+    return Promise.resolve(null);
+  }
+  login() {
+    return Promise.resolve(void 0);
+  }
+}
+class Navigator {
+  constructor() {
+    this.basename = "";
+    this.origin = "";
+    this.value = {
+      action: Action.Push,
+      location: null,
+      delta: null
+    };
+    this.location = null;
+    this.action = Action$2.Push;
+    this.createHref = cy.stub().as("createHref");
+    this.createURL = cy.stub().as("createURL");
+    this.encodeLocation = cy.stub().as("encodeLocation");
+    this.push = cy.stub().as("push");
+    this.replace = cy.stub().as("replace");
+    this.go = cy.stub().as("go");
+    this.listen = cy.stub().as("listen");
+  }
+}
+class RomaMockedNavigationModule {
+  constructor() {
+    this.dispose = cy.stub();
+    this.navigator = new Navigator();
+    this.path = { pathname: "string", search: "string", hash: "string" };
+    this.state$ = of({
+      action: Action.Push,
+      location: this.path
+    });
+    this.createHref = cy.stub().as("createHref.module");
+    this.createRouter = cy.stub().as("createRouter");
+    this.createURL = cy.stub().as("createURL.module");
+    this.push = cy.stub().as("push.module");
+    this.replace = cy.stub().as("replace.module");
+  }
+}
+class RomaMockedHttpClient {
+  hasClient() {
+    return true;
+  }
+  createClient() {
+    return {
+      fetch: (url, options) => {
+        return fetch(url.startsWith("/") ? url : `/${url}`, options);
+      },
+      fetch$(path, init) {
+        return from(this.fetch(path, init));
+      },
+      fetchAsync(path, args) {
+        return this.fetch(path, args);
+      },
+      async blob(path, args) {
+        const r = await fetch(path, args);
+        return await r.blob();
+      },
+      blob$(path, args) {
+        return from(this.blob(path, args));
+      },
+      async json(path, init) {
+        const r = await this.fetch(path, init);
+        return await r.json();
+      },
+      json$(path, init) {
+        return from(this.json(path, init));
+      },
+      jsonAsync(path, args) {
+        return this.json(path, args);
+      },
+      uri: ""
+    };
+  }
+  createCustomClient() {
+    return this.createClient();
+  }
+}
+class Connection {
+  constructor(messages = []) {
+    this.interval$ = interval(50);
+    this.setReadState = cy.stub().as("setReadState");
+    this.messageList = new BehaviorSubject(messages);
+    this.messageList$ = this.messageList;
+  }
+  async setAllRead() {
+    const currentValues = await firstValueFrom(this.messageList);
+    const newValues = [...currentValues].map((v) => ({ ...v, read: true }));
+    this.messageList.next(newValues);
+  }
+}
+class RomaMockedSseModule {
+  constructor(messageList = []) {
+    this.messageList = messageList;
+    const connection = this.connect("activity");
+    this.connections = new Proxy(
+      {},
+      {
+        get: () => connection
+      }
+    );
+  }
+  connect(name) {
+    return new Connection(this.messageList ?? []);
+  }
+  createConnection(name, options) {
+  }
+}
+const RomaCypressWrapper = ({
+  children,
+  events
+}) => {
+  const navigation = new RomaMockedNavigationModule();
+  const http = new RomaMockedHttpClient();
+  const auth = new RomaMockedAuthModule();
+  const serviceDiscovery = new RomaMockedServiceDiscovery();
+  const sse = new RomaMockedSseModule(events ?? []);
+  return /* @__PURE__ */ jsx(
+    FrameworkProvider,
+    {
+      value: {
+        modules: {
+          dispose: () => {
+          },
+          navigation,
+          sse,
+          http,
+          auth,
+          serviceDiscovery
+        }
+      },
+      children: /* @__PURE__ */ jsx(
+        ModuleProvider,
+        {
+          value: {
+            navigation,
+            http,
+            auth
+          },
+          children: /* @__PURE__ */ jsx(
+            QueryClientProvider,
+            {
+              client: new QueryClient({
+                defaultOptions: {
+                  queries: {
+                    staleTime: Infinity,
+                    refetchInterval: false,
+                    refetchIntervalInBackground: false,
+                    refetchOnMount: false,
+                    refetchOnReconnect: false,
+                    refetchOnWindowFocus: false,
+                    retry: false
+                  }
+                }
+              }),
+              children: /* @__PURE__ */ jsx(IntlProvider, { locale: "en-US", children })
+            }
+          )
+        }
+      )
+    }
+  );
+};
+const mount = (component, options = {}) => {
+  var _a;
+  return mount$1(
+    /* @__PURE__ */ jsx(RomaCypressWrapper, { events: (_a = options.moduleConfig) == null ? void 0 : _a.events, children: component }),
+    options
+  );
+};
+export {
+  mount
+};