@beinformed/ui 1.65.13 → 1.65.15

package/src/utils/fetch/xhr.js

@@ -1,409 +0,0 @@
-// @flow
-import { has, isPlainObject } from "../helpers/objects";
-
-import {
-  IllegalArgumentException,
-  UnauthorizedException,
-  FetchException,
-  TimeoutException,
-  NotFoundException,
-  JsonParseException,
-  NetworkException,
-} from "../../exceptions";
-
-import Cache from "../browser/Cache";
-
-import { HTTP_METHODS } from "../../constants/Constants";
-
-import { getSetting } from "../../constants/Settings";
-
-import type { RequestOptions } from "./types";
-
-const NETWORK_ERROR_CODE = 0;
-const SUCCESS_CODE = 200;
-const CLIENT_ERROR_CODE = 400;
-const UNAUTHORIZED_CODE = 401;
-const REDIRECTION_CODE = 300;
-const NOT_FOUND_CODE = 404;
-
-const JSON_TYPE = "application/json";
-
-/**
- * @private
- */
-class XHR {
-  _options: RequestOptions;
-  _xmlhttp: XMLHttpRequest;
-  _attempts: number;
-
-  /**
-   */
-  constructor(options: RequestOptions) {
-    this._options = options;
-    this._attempts = 0;
-  }
-
-  /**
-   */
-  get xmlhttp(): XMLHttpRequest {
-    return this._xmlhttp;
-  }
-
-  /**
-   */
-  set xmlhttp(xmlhttp: XMLHttpRequest) {
-    this._xmlhttp = xmlhttp;
-  }
-
-  /**
-   */
-  get options(): RequestOptions {
-    return this._options;
-  }
-
-  /**
-   */
-  set options(options: RequestOptions) {
-    this._options = options;
-  }
-
-  /**
-   */
-  get attempts(): number {
-    return this._attempts;
-  }
-
-  /**
-   */
-  set attempts(attempts: number) {
-    this._attempts = attempts;
-  }
-
-  /**
-   * Create and fix url when params or both querystring and params exist.
-   */
-  get url(): string {
-    const { url } = this.options;
-    if (this.params !== "") {
-      if (url.includes("?")) {
-        const aUrl = url.split("?");
-
-        return `${aUrl[0]}?${aUrl[1]}&${this.params}`;
-      }
-
-      return `${url}?${this.params}`;
-    }
-
-    return url;
-  }
-
-  /**
-   */
-  get params(): string {
-    return this.options.params || "";
-  }
-
-  /**
-   */
-  get data(): any | null {
-    return this.options.data || null;
-  }
-
-  /**
-   */
-  get method(): $Keys<typeof HTTP_METHODS> {
-    return this.options.method || HTTP_METHODS.GET;
-  }
-
-  /**
-   */
-  get timeout(): number {
-    return this.options.timeout || getSetting("XHR_TIMEOUT_MS", 300000);
-  }
-
-  /**
-   */
-  get responseType(): string {
-    return this.options.responseType || "json";
-  }
-
-  /**
-   */
-  get onProgress(): ProgressEventHandler {
-    if (this.options.onProgress) {
-      return this.options.onProgress;
-    }
-
-    return () => {
-      // do nothing
-    };
-  }
-
-  /**
-   */
-  get events(): { [eventName: string]: () => void } {
-    return this.options.events || {};
-  }
-
-  /**
-   */
-  getBaseLocale(): string {
-    if (typeof navigator !== "undefined" && navigator.language) {
-      return navigator.language.split("-")[0] || "en";
-    }
-
-    return "en";
-  }
-
-  /**
-   */
-  get headers(): { [string]: string } {
-    const baseHeaders = {
-      Accept: JSON_TYPE,
-      "Content-Type": JSON_TYPE,
-
-      // needed for csrf, see: https://plaza.beinformed.com/amdoc/csrf-protection-in-modular-ui-services-40054554.html
-      "X-Requested-With": "XMLHttpRequest",
-
-      "Accept-Language": this.getBaseLocale(),
-    };
-
-    if (this.options.headers) {
-      // $FlowFixMe[cannot-spread-indexer]
-      return {
-        ...baseHeaders,
-        ...this.options.headers,
-      };
-    }
-
-    return baseHeaders;
-  }
-
-  /**
-   */
-  timeoutHandler(reject: Function): any {
-    return reject(new TimeoutException(this.url, this.method));
-  }
-
-  /**
-   */
-  errorHandler(reject: Function, responseJSON: any = null): any {
-    const { status } = this.xmlhttp;
-    const { isReload } = this.options;
-
-    if (status === NETWORK_ERROR_CODE) {
-      return reject(new NetworkException(this.url, this.method));
-    }
-
-    if (status === NOT_FOUND_CODE) {
-      return reject(new NotFoundException(this.url, this.method, isReload));
-    }
-
-    if (status === UNAUTHORIZED_CODE) {
-      return reject(
-        new UnauthorizedException(this.url, this.method, responseJSON),
-      );
-    }
-
-    return reject(new FetchException(responseJSON, this.xmlhttp, this.options));
-  }
-
-  /**
-   */
-  getResponse(): any {
-    const { responseType, response } = this.xmlhttp;
-
-    if (
-      (responseType === "" || responseType === "text") &&
-      this.getResponseHeader("Content-Type") === JSON_TYPE
-    ) {
-      if (isPlainObject(response)) {
-        return response;
-      }
-
-      try {
-        return JSON.parse(response);
-      } catch (error) {
-        throw new JsonParseException(error);
-      }
-    }
-
-    return response;
-  }
-
-  /**
-   */
-  responseHandler(resolve: Function, reject: Function): any {
-    const { status } = this.xmlhttp;
-
-    let response = null;
-    try {
-      response = this.getResponse();
-    } catch (error) {
-      return reject(error);
-    }
-
-    if (
-      (status >= SUCCESS_CODE && status < REDIRECTION_CODE) ||
-      (status === CLIENT_ERROR_CODE && has(response, "formresponse"))
-    ) {
-      return resolve(response);
-    }
-
-    return this.errorHandler(reject, response);
-  }
-
-  /**
-   */
-  setEventListeners(resolve: Function, reject: Function) {
-    if (this.options.onProgress) {
-      ["load", "loadend", "loadstart", "progress"].forEach((eventType) => {
-        this.xmlhttp.addEventListener(eventType, this.onProgress);
-      });
-    }
-
-    ["abort", "error"].forEach((eventType) => {
-      this.xmlhttp.addEventListener(eventType, () => this.errorHandler(reject));
-    });
-
-    this.xmlhttp.addEventListener("timeout", () => this.timeoutHandler(reject));
-
-    this.xmlhttp.addEventListener("load", () =>
-      this.responseHandler(resolve, reject),
-    );
-
-    // Set custom events
-    Object.keys(this.events).forEach((eventName) => {
-      this.xmlhttp.addEventListener(eventName, this.events[eventName]);
-    });
-  }
-
-  /**
-   */
-  openConnection() {
-    this.xmlhttp.open(this.method, this.url, true);
-  }
-
-  /**
-   */
-  setBasicAuthentication() {
-    if (Cache.hasItem("basic")) {
-      const basicToken = Cache.getItem("basic");
-
-      if (typeof basicToken === "string") {
-        this.xmlhttp.setRequestHeader("Authorization", `Basic ${basicToken}`);
-      }
-    }
-  }
-
-  /**
-   */
-  getResponseHeader(headerName: string): string | null {
-    return this.xmlhttp.getResponseHeader(headerName);
-  }
-
-  /**
-   */
-  setCustomHeaders() {
-    Object.keys(this.headers).forEach((headerName) => {
-      this.xmlhttp.setRequestHeader(headerName, this.headers[headerName]);
-    });
-  }
-
-  /**
-   */
-  setOtherOptions() {
-    if (
-      this.options.withCredentials ||
-      getSetting("XHR_ALWAYS_WITH_CREDENTIALS", Cache.hasItem("basic"))
-    ) {
-      this.xmlhttp.withCredentials = true;
-    }
-    this.xmlhttp.responseType = this.responseType;
-    this.xmlhttp.timeout = this.timeout;
-  }
-
-  /**
-   */
-  sendData() {
-    if (this.data == null) {
-      this.xmlhttp.send();
-    } else {
-      const stringData = isPlainObject(this.data)
-        ? JSON.stringify(this.data)
-        : this.data;
-      this.xmlhttp.send(stringData);
-    }
-  }
-
-  /**
-   */
-  setXMLHttpRequest(): Promise<any> {
-    return new Promise((resolve, reject) => {
-      this.xmlhttp = new XMLHttpRequest();
-
-      this.setEventListeners(resolve, reject);
-
-      this.openConnection();
-
-      this.setBasicAuthentication();
-
-      this.setCustomHeaders();
-
-      this.setOtherOptions();
-
-      this.sendData();
-    });
-  }
-
-  /**
-   */
-  async fetch(): Promise<any> {
-    try {
-      return await this.setXMLHttpRequest();
-    } catch (err) {
-      if (err instanceof NetworkException && this.attempts < 2) {
-        this.attempts += 1;
-        return this.fetch();
-      }
-
-      throw err;
-    }
-  }
-}
-
-/**
- */
-const validateInputArguments = (args: RequestOptions) => {
-  if (args == null) {
-    throw new IllegalArgumentException(
-      "Missing request options, expecting an object as argument for xhr",
-    );
-  }
-
-  if (!isPlainObject(args)) {
-    throw new IllegalArgumentException(
-      `Expecting an object as argument for xhr, but received: ${args.toString()}`,
-    );
-  }
-
-  if (!has(args, "url")) {
-    throw new IllegalArgumentException(
-      `No url property found in arguments of xhr, received: ${JSON.stringify(
-        args,
-      )}`,
-    );
-  }
-
-  return true;
-};
-
-/**
- */
-const xhr = (args: RequestOptions): Promise<any> => {
-  validateInputArguments(args);
-
-  return new XHR(args).fetch();
-};
-
-export default xhr;

package/src/utils/helpers/__tests__/checkResource.spec.js

@@ -1,60 +0,0 @@
-import {
-  resourceExists,
-  resourceRedirectsToSecureLogin,
-} from "../checkResource";
-
-import Href from "../../../models/href/Href";
-
-const mockXMLHttpRequest = () => {
-  const mock = {
-    open: jest.fn(),
-    addEventListener: jest.fn(),
-    setRequestHeader: jest.fn(),
-    send: jest.fn(),
-    getResponseHeader: jest.fn(),
-
-    upload: {
-      addEventListener: jest.fn(),
-    },
-  };
-
-  jest.spyOn(global, "XMLHttpRequest").mockImplementation(() => mock);
-
-  return mock;
-};
-
-describe("checkResource", () => {
-  it("indicates a resource exists if it has a status code other then 404", () => {
-    const mock = mockXMLHttpRequest();
-    mock.status = 200;
-
-    const exists = resourceExists("/");
-    expect(exists).toBe(true);
-
-    const hrefExists = resourceExists(new Href("/caseview"));
-    expect(hrefExists).toBe(true);
-  });
-
-  it("indicates a resource does not exists if it has a status code of 404", () => {
-    const mock = mockXMLHttpRequest();
-    mock.status = 404;
-
-    const exists = resourceExists("/");
-    expect(exists).toBe(false);
-
-    const hrefExists = resourceExists(new Href("/caseview"));
-    expect(hrefExists).toBe(false);
-  });
-
-  it("indicates resource request redirects to secureLogin", () => {
-    const mock = mockXMLHttpRequest();
-    mock.responseURL = "/BeInformed/secureLogin";
-    mock.status = 400;
-
-    const toLogin = resourceRedirectsToSecureLogin("/");
-    expect(toLogin).toBe(true);
-
-    const hrefToLogin = resourceExists(new Href("/caseview"));
-    expect(hrefToLogin).toBe(true);
-  });
-});

package/src/utils/helpers/__tests__/createHash.spec.js

@@ -1,11 +0,0 @@
-import { createHash } from "../createHash";
-
-describe("createHash", () => {
-  it("creates hash from string", () => {
-    expect(createHash("")).toBe(729279156);
-    expect(createHash("abcdefgh")).toBe(17595859189820);
-    expect(createHash(123455)).toBe(15900277965517);
-    expect(createHash(null)).toBe(711079339769);
-    expect(createHash()).toBe(4721361581144);
-  });
-});

package/src/utils/helpers/__tests__/createHref.spec.js

@@ -1,39 +0,0 @@
-import { createHref } from "../createHref";
-import Href from "../../../models/href/Href";
-
-describe("createHref", () => {
-  it("can filter out qs parameters", () => {
-    const dynamicPart = "project/folder/model.bixml/ConceptId";
-    const location = {
-      search: "?entryDate=2024-03-08&index=C&notAllowed=true",
-    };
-    const expectedSearch = "?index=C&notAllowed=true&entryDate=2010-01-01";
-
-    expect(createHref("concepts", dynamicPart)).toEqual(
-      new Href("/concepts/" + dynamicPart),
-    );
-    expect(createHref("concepts", dynamicPart, "2010-01-01", location)).toEqual(
-      new Href("/concepts/" + dynamicPart + expectedSearch),
-    );
-    expect(
-      createHref("concepts", dynamicPart, "2010-01-01", location, ["index"]),
-    ).toEqual(
-      new Href("/concepts/" + dynamicPart + "?index=C&entryDate=2010-01-01"),
-    );
-    expect(
-      createHref(
-        "concepts",
-        dynamicPart + location.search,
-        "2010-01-01",
-        location,
-        ["index"],
-      ),
-    ).toEqual(
-      new Href("/concepts/" + dynamicPart + "?index=C&entryDate=2010-01-01"),
-    );
-
-    expect(createHref("concepts", dynamicPart + "#hash")).toEqual(
-      new Href("/concepts/" + dynamicPart + "#hash"),
-    );
-  });
-});

package/src/utils/helpers/__tests__/objects.spec.js

@@ -1,50 +0,0 @@
-import { get, has, isPlainObject } from "../objects";
-
-describe("objects", () => {
-  it("can get stuff or return default", () => {
-    const obj = {
-      a: {
-        b: {
-          c: 42,
-        },
-      },
-    };
-
-    expect(get(obj, "a.b.c", "fortytwo")).toBe(42);
-    expect(get(obj, "a.b.d", "fortytwo")).toBe("fortytwo");
-    expect(get(obj, "non-existing")).toBeUndefined();
-    expect(get(obj, "a.b")).toStrictEqual({ c: 42 });
-    expect(get("string", "a.b")).toBeUndefined();
-  });
-
-  it("can check path on object", () => {
-    const obj = {
-      a: {
-        b: {
-          c: 42,
-        },
-      },
-    };
-
-    expect(has(obj, "a.b.c")).toBe(true);
-    expect(has(obj, "a.b.d")).toBe(false);
-    expect(has(obj, "non-existing")).toBe(false);
-    expect(has(obj, "a.b")).toBe(true);
-    expect(has("string", "a.b")).toBe(false);
-    expect(has(null, "a")).toBe(false);
-    expect(has(undefined, "a")).toBe(false);
-  });
-
-  it("can check for plain objects", () => {
-    expect(isPlainObject({})).toBe(true);
-    expect(isPlainObject({ param: "value" })).toBe(true);
-    expect(isPlainObject("string")).toBe(false);
-    expect(isPlainObject(["a", "b", "c"])).toBe(false);
-    expect(isPlainObject(new Set([1, 2, 3]))).toBe(false);
-    expect(isPlainObject(new Date())).toBe(false);
-    expect(isPlainObject(new File([""], "filename"))).toBe(false);
-    expect(isPlainObject(undefined)).toBe(false);
-    expect(isPlainObject(null)).toBe(false);
-    expect(isPlainObject(1)).toBe(false);
-  });
-});

package/src/utils/helpers/__tests__/sanitizeHTML.spec.js

@@ -1,69 +0,0 @@
-import { removeUnwantedHtml } from "../sanitizeHtml";
-
-describe("sanitizeHTML", () => {
-  it("remove unwanted html", () => {
-    expect(removeUnwantedHtml("String without HTML")).toBe(
-      "String without HTML",
-    );
-
-    expect(
-      removeUnwantedHtml("<p>String with <b>allowed <i>html</i></b></p>"),
-    ).toBe("<p>String with <b>allowed <i>html</i></b></p>");
-
-    expect(
-      removeUnwantedHtml(
-        "<p>String with <b>allowed <i>html</i></b><br /> and <blink>NOT</blink> allowed html</p>",
-      ),
-    ).toBe(
-      "<p>String with <b>allowed <i>html</i></b><br /> and NOT allowed html</p>",
-    );
-
-    expect(
-      removeUnwantedHtml("String<p><br /> with <u>allowed</u></p> html"),
-    ).toBe("String<p><br /> with <u>allowed</u></p> html");
-
-    expect(
-      removeUnwantedHtml(
-        '<p>String <b style="font-weight: 400" id="bold">not allowed attribute</b> string</p>',
-      ),
-    ).toBe("<p>String <b>not allowed attribute</b> string</p>");
-  });
-
-  it("Should keep escaped html", () => {
-    expect(
-      removeUnwantedHtml(
-        "<p>Keep &lt;cite&gt;cite tag&lt;/cite&gt; and remove <cite>real cite tag</cite>",
-      ),
-    ).toBe(
-      "<p>Keep &lt;cite&gt;cite tag&lt;/cite&gt; and remove real cite tag",
-    );
-  });
-
-  it("Can encode special characters to numerical characters", () => {
-    expect(removeUnwantedHtml("<p>foo © bar ≠ baz 𝌆 qux   bla</p>")).toBe(
-      "<p>foo &#169; bar &#8800; baz &#119558; qux   bla</p>",
-    );
-
-    expect(
-      removeUnwantedHtml(
-        "<p>foo &#169; bar &#8800; baz &#119558; qux &#160; bla</p>",
-      ),
-    ).toBe("<p>foo &#169; bar &#8800; baz &#119558; qux &#160; bla</p>");
-  });
-
-  it("Keeps brackets", () => {
-    expect(
-      removeUnwantedHtml(
-        "The list of children [ Peter, Steven, Susan ] is up to date.",
-      ),
-    ).toBe("The list of children [ Peter, Steven, Susan ] is up to date.");
-  });
-
-  it("Keeps curly brackets", () => {
-    expect(
-      removeUnwantedHtml(
-        "The list of children { Peter, Steven, Susan } is up to date.",
-      ),
-    ).toBe("The list of children { Peter, Steven, Susan } is up to date.");
-  });
-});

package/src/utils/helpers/checkResource.js

@@ -1,43 +0,0 @@
-// @flow
-import Href from "../../models/href/Href";
-
-/**
- * Checks if a given url to a modular ui resource exists using a HEAD request to the resource (synchronous)
- * When the resource returns a 404, the resource does not exists and the method returns false
- *
- * @param url
- * @returns {boolean}
- */
-export const resourceExists = (url: string | Href): boolean => {
-  const fullUrl = new Href(url).absolutehref;
-
-  const xhr = new XMLHttpRequest();
-  xhr.open("HEAD", fullUrl, false);
-  xhr.setRequestHeader("Accept", "application/json");
-  xhr.setRequestHeader("Content-Type", "application/json");
-  xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-
-  xhr.send();
-
-  return xhr.status !== 404;
-};
-
-/**
- * Indicates if a request to the given url resuls in a redirect to /secureRedirect
- * @param url
- * @returns {boolean}
- */
-export const resourceRedirectsToSecureLogin = (url: string | Href): boolean => {
-  const fullUrl = new Href(url).absolutehref;
-
-  const xhr = new XMLHttpRequest();
-  xhr.open("HEAD", fullUrl, false);
-  xhr.setRequestHeader("Accept", "application/json");
-  xhr.setRequestHeader("Content-Type", "application/json");
-  xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-  xhr.send();
-
-  const responseURL = xhr.responseURL ?? "";
-
-  return xhr.status === 400 && responseURL.endsWith("/secureLogin");
-};

package/src/utils/helpers/createHash.js

@@ -1,28 +0,0 @@
-// @flow
-import { hash } from "hash-it";
-
-import type Href from "../../models/href/Href";
-import type { SectionFragment } from "../../models";
-
-/**
- * https://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
- */
-const createHash = (str: string): number => {
-  return hash(str);
-};
-
-/**
- */
-const createHashFromHref = (href: Href, fragment?: SectionFragment): number => {
-  const hrefString = href.hash
-    ? [href.toString(), href.hash].join("#")
-    : href.toString();
-
-  if (fragment) {
-    return hash({ hrefString, fragment });
-  }
-
-  return hash(hrefString);
-};
-
-export { createHash, createHashFromHref };