@beinformed/ui 1.65.12 → 1.65.14

package/src/utils/helpers/createHref.js

@@ -1,117 +0,0 @@
-// @flow
-import Href from "../../models/href/Href";
-
-import type { Location } from "react-router";
-
-/**
- */
-export const parseUrl = (
-  href: string | Href,
-): { path: string, querystring: null | string, hash: null | string } => {
-  if (href instanceof Href) {
-    return {
-      path: href.path,
-      querystring: href.querystring,
-      hash: href.hash,
-    };
-  }
-
-  let path = href;
-  let hash = null;
-  let querystring = null;
-  if (href.includes("#")) {
-    const hashSplit = href.split("#");
-    path = hashSplit[0];
-    hash = hashSplit[1];
-  }
-  if (href.includes("?")) {
-    const qsSplit = path.split("?");
-    path = qsSplit[0];
-    querystring = qsSplit[1];
-  }
-  return {
-    path,
-    querystring,
-    hash,
-  };
-};
-
-/**
- */
-export const filterParameters = (
-  href: string | Href,
-  allowedParameters?: Array<string>,
-): Href => {
-  if (!Array.isArray(allowedParameters)) {
-    return new Href(href);
-  }
-
-  const url = parseUrl(href);
-  let filteredUrl = url.path;
-  if (url.querystring) {
-    const searchParams = new URLSearchParams(url.querystring);
-    const params = Array.from(searchParams.keys());
-    for (const param of params) {
-      if (!allowedParameters.includes(param)) {
-        searchParams.delete(param);
-      }
-    }
-    filteredUrl = filteredUrl + "?" + searchParams.toString();
-  }
-  if (url.hash) {
-    filteredUrl = filteredUrl + "#" + url.hash;
-  }
-
-  if (href instanceof Href) {
-    return new Href(filteredUrl, href.resourcetype, {
-      origin: href.origin,
-      contextPath: href.contextPath,
-    });
-  }
-
-  return new Href(filteredUrl);
-};
-
-/**
- */
-export const createHref = (
-  context: string,
-  dynamicPart: string | Href,
-  entryDate?: ?ISO_DATE,
-  location?: ?Location,
-  allowedParameters?: Array<string>,
-): Href => {
-  let href = dynamicPart.toString();
-
-  if (!href.startsWith(`/${context}/`)) {
-    href = `/${context}/${href}`;
-  }
-
-  href = href.replace(/\/\//g, "/");
-
-  if (location?.search && !href.includes("?")) {
-    const search = location.search.startsWith("?")
-      ? location.search.substring(1)
-      : location.search;
-    href = `${href}?${search}`;
-  }
-
-  const finalHref =
-    dynamicPart instanceof Href
-      ? filterParameters(
-          new Href(href, dynamicPart.resourcetype, {
-            origin: dynamicPart.origin,
-            contextPath: dynamicPart.contextPath,
-          }),
-          allowedParameters,
-        )
-      : filterParameters(href, allowedParameters);
-
-  if (entryDate) {
-    finalHref.setParameter("entryDate", entryDate);
-  } else {
-    finalHref.removeParameter("entryDate");
-  }
-
-  return finalHref;
-};

package/src/utils/helpers/createUUID.js

@@ -1,13 +0,0 @@
-// @flow
-/**
- */
-const createUUID = (): string => {
-  let d = new Date().getTime();
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = ((d + Math.random() * 16) % 16) | 0;
-    d = Math.floor(d / 16);
-    return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
-  });
-};
-
-export default createUUID;

package/src/utils/helpers/index.js

@@ -1,9 +0,0 @@
-// @flow
-export * from "./createHash";
-export { default as createUUID } from "./createUUID";
-export * from "./sanitizeHtml";
-export * from "./objects";
-export * from "./text";
-export * from "./checkResource";
-export * from "./repositoryResource";
-export * from "./createHref";

package/src/utils/helpers/objects.js

@@ -1,33 +0,0 @@
-// @flow
-import _has from "lodash/has";
-import _isPlainObject from "lodash/isPlainObject";
-
-/**
- */
-const isPlainObject = (value: any): boolean => _isPlainObject(value);
-
-/**
- */
-const has = (obj: any, propName: string): boolean => {
-  if (!isPlainObject(obj)) {
-    return false;
-  }
-
-  return _has(obj, propName);
-};
-
-/**
- * Retrieve property of an object
- * When path is only one deep better use optional chaining
- */
-const get = (obj: Object, path: string, defaultValue?: any): any =>
-  String(path)
-    .split(".")
-    .reduce((acc, v) => {
-      if (typeof acc === "object") {
-        return acc[v] ?? defaultValue;
-      }
-      return defaultValue;
-    }, obj);
-
-export { get, has, isPlainObject };

package/src/utils/helpers/repositoryResource.js

@@ -1,22 +0,0 @@
-// @flow
-import { getBasePathServer, RESOURCE_PATH } from "../../constants";
-
-/**
- * Creates an url to a resource in the Be Informed repository
- * Only possible when serving using the UI Servlet of Be Informed
- */
-export const getRepositoryResourceUrl = (
-  resourceUrl: string,
-  contextPath: string = getBasePathServer(),
-  origin: string = "",
-): string => {
-  if (resourceUrl.startsWith(origin + contextPath)) {
-    return resourceUrl;
-  }
-
-  if (resourceUrl.startsWith(RESOURCE_PATH)) {
-    return `${origin}${contextPath}${resourceUrl}`;
-  }
-
-  return `${origin}${contextPath}${RESOURCE_PATH}${resourceUrl}`;
-};

package/src/utils/helpers/sanitizeHtml.js

@@ -1,55 +0,0 @@
-// @flow
-import { encode } from "html-entities";
-
-import { IllegalArgumentException } from "../../exceptions";
-
-type removeUnwantedHtmlOptions = {
-  allowedTags?: Array<string>,
-};
-
-/**
- * Translates html entities to their correct decimal equivalent
- * When path is only one deep better use optional chaining
- */
-const properEntityEncoding = (html: string) => {
-  return encode(html, { mode: "nonAsciiPrintableOnly", level: "xml" });
-};
-
-/**
- * removes unwanted html, this might result in incorrect html, as it removes all html that we don't except,
- * like <b style="font-weight: 400">bold</b> will result in bold</b>
- */
-const removeUnwantedHtml = (
-  html: string,
-  options: removeUnwantedHtmlOptions = {
-    allowedTags: ["p", "br", "b", "i", "u", "strike"],
-  },
-): string => {
-  if (typeof html !== "string") {
-    throw new IllegalArgumentException("sanitizeHTML method expects a string");
-  }
-
-  const correctEntityHtml = properEntityEncoding(html);
-
-  // remove attributes from html elements
-  const htmlWithoutAttributes = correctEntityHtml.replace(
-    /<(\w+)(.|[\r\n])*?>/gi,
-    "<$1>",
-  );
-
-  const htmlWithCorrectBR = htmlWithoutAttributes.replace(
-    /<br\s*>/gi,
-    "<br />",
-  );
-
-  // remove not allowed tags
-  const allowedTags = Array.isArray(options.allowedTags)
-    ? options.allowedTags.join("|")
-    : "";
-  const pattern = `<(?!\\/?(${allowedTags})(>|\\s\\/))[^<]+?>`;
-  const regex = new RegExp(pattern, "gi");
-
-  return htmlWithCorrectBR.replace(regex, "");
-};
-
-export { removeUnwantedHtml };

package/src/utils/helpers/text.js

@@ -1,23 +0,0 @@
-// @flow
-import { isPlainObject } from "./objects";
-
-/**
- * Handles text that is in the ApplicationMessage form ({ id: string, message: string, properties: object })
- * @param text
- * @returns {string}
- */
-export const retrieveText = (
-  text:
-    | string
-    | { id?: string, message: string, properties?: { [key: string]: any } },
-): string | null => {
-  if (typeof text === "string") {
-    return text;
-  }
-
-  if (isPlainObject(text) && "message" in text) {
-    return text.message;
-  }
-
-  return null;
-};

package/src/utils/index.js

@@ -1,22 +0,0 @@
-// @flow
-
-// browser
-export { default as Cache } from "./browser/Cache";
-export * from "./browser/Cookies";
-
-// datetime
-export * from "./datetime/DateTimeUtil";
-
-// fetch
-export { default as serverFetch } from "./fetch/serverFetch";
-export { default as universalFetch } from "./fetch/universalFetch";
-export { default as xhr } from "./fetch/xhr";
-export type * from "./fetch/types";
-
-// helpers
-export * from "./helpers";
-
-// number
-export { default as DecimalFormat } from "./number/DecimalFormat";
-export { default as formatValue } from "./number/formatValue";
-export * from "./number/parseNumbers";

package/src/utils/number/DecimalFormat.js

@@ -1,410 +0,0 @@
-// @flow
-// @see: https://docs.oracle.com/javase/tutorial/i18n/format/decimalFormat.html
-/**
- */
-class DecimalFormat {
-  _prefix: string;
-  _suffix: string;
-
-  // Grouping size
-  _comma: number;
-  // Minimum integer digits to be displayed
-  _minInt: number;
-
-  // Minimum fractional digits to be displayed
-  _minFrac: number;
-  // Maximum fractional digits to be displayed
-  _maxFrac: number;
-
-  _isPercentage: boolean;
-
-  /**
-   */
-  constructor(format: string) {
-    this.setAffix(format);
-    this.setFractionLengths(format);
-    this.setGroupLength(format);
-    this.setMinLength(format);
-
-    this.setPercentage();
-  }
-
-  /**
-   */
-  get prefix(): string {
-    return this._prefix;
-  }
-
-  /**
-   */
-  get suffix(): string {
-    return this._suffix;
-  }
-
-  /**
-   */
-  get comma(): number {
-    return this._comma;
-  }
-
-  /**
-   */
-  get minInt(): number {
-    return this._minInt;
-  }
-
-  /**
-   */
-  get minFrac(): number {
-    return this._minFrac;
-  }
-
-  /**
-   */
-  get maxFrac(): number {
-    return this._maxFrac;
-  }
-
-  /**
-   */
-  get isPercentage(): boolean {
-    return this._isPercentage;
-  }
-
-  /**
-   */
-  setAffix(format: string) {
-    const beforeDigit = format.includes("#")
-      ? format.substring(0, format.indexOf("#"))
-      : format;
-
-    this._prefix = beforeDigit.includes("0")
-      ? beforeDigit.substring(0, beforeDigit.indexOf("0"))
-      : beforeDigit;
-    this._suffix = format
-      .substring(this._prefix.length)
-      .replace(/[#,.0]/gu, "");
-  }
-
-  /**
-   */
-  setFractionLengths(format: string) {
-    this._minFrac = 0;
-    this._maxFrac = 0;
-
-    const numberStr = format.replace(/[^#,.0]/gu, "");
-    if (numberStr.includes(".")) {
-      const fracStr = numberStr.substring(numberStr.indexOf(".") + 1);
-
-      const maxFrac = fracStr.replace(/,|\.+/g, "");
-      this._maxFrac = maxFrac.length;
-
-      // replace all but zeros
-      const minFrac = maxFrac.replace(/[^0]/gu, "");
-      this._minFrac = minFrac.length;
-    }
-  }
-
-  /**
-   */
-  setGroupLength(format: string) {
-    this._comma = 0;
-
-    const numberStr = format.replace(/[^#,.0]/gu, "");
-    const intStr = numberStr.includes(".")
-      ? numberStr.substring(0, numberStr.indexOf("."))
-      : numberStr;
-
-    if (intStr.includes(",")) {
-      this._comma = intStr.length - 1 - intStr.lastIndexOf(",");
-    }
-  }
-
-  /**
-   */
-  setMinLength(format: string) {
-    const intFormatStr = format.includes(".")
-      ? format.substring(0, format.indexOf("."))
-      : format;
-    const intStr = intFormatStr.replace(/[^0]/gu, "");
-
-    this._minInt = intStr.length > 1 ? intStr.length : 1;
-  }
-
-  /**
-   */
-  setPercentage() {
-    this._isPercentage = this.suffix.charAt(0) === "%";
-  }
-
-  /**
-   * Solves problem where big numbers loose the precision:
-   * e.g. Number(23423423423342234.34) => 23423423423342236
-   */
-  static getNumericString(stringNumber: string): string {
-    const number = Number(stringNumber);
-    const string = String(number);
-
-    if (!string.includes(".") && stringNumber.includes(".")) {
-      // check if original string has all zeros after dot or not
-      const precision = stringNumber.substring(stringNumber.indexOf(".") + 1);
-      if (precision.replace(/0/gu, "").length > 0) {
-        return stringNumber;
-      }
-
-      return string;
-    }
-
-    return stringNumber;
-  }
-
-  /**
-   * Converts formatted value back to non-formatted value
-   * e.g. $1,223.06 --> 1223.06
-   */
-  formatBack(formattedNumber: string): string {
-    const stringNumber = String(formattedNumber);
-
-    if (!stringNumber) {
-      return "";
-    }
-
-    if (!isNaN(stringNumber)) {
-      return DecimalFormat.getNumericString(stringNumber);
-    }
-
-    let tempNumber = formattedNumber;
-
-    let negative = false;
-    if (formattedNumber.charAt(0) === "-") {
-      tempNumber = formattedNumber.substr(1);
-      negative = true;
-    }
-
-    const hasPrefix = formattedNumber.startsWith(this.prefix);
-
-    const suffixIndex =
-      this.suffix === ""
-        ? formattedNumber.length
-        : formattedNumber.indexOf(this.suffix, this.prefix.length + 1);
-
-    if (hasPrefix && suffixIndex > 0) {
-      tempNumber = tempNumber.substr(0, suffixIndex);
-      tempNumber = tempNumber.substr(this.prefix.length);
-      tempNumber = tempNumber.replace(/,/gu, "");
-
-      if (negative) {
-        tempNumber = `-${tempNumber}`;
-      }
-
-      if (!isNaN(tempNumber)) {
-        return DecimalFormat.getNumericString(tempNumber);
-      }
-    }
-
-    return tempNumber;
-  }
-
-  /**
-   */
-  static scientificNumber(stringNumber: string): string {
-    if (stringNumber.includes("e")) {
-      const number = Number(stringNumber);
-      if (number === Infinity || number === -Infinity) {
-        return stringNumber;
-      }
-
-      return String(number);
-    }
-
-    return stringNumber;
-  }
-
-  /**
-   */
-  getFracAsNumber(fracStr: string): string {
-    const number = Number(`0.${fracStr}`);
-    const DECIMAL_RADIX = 10;
-
-    return this.maxFrac === 0
-      ? Math.round(number).toString(DECIMAL_RADIX)
-      : number.toFixed(this.maxFrac);
-  }
-
-  /**
-   */
-  getRoundedFrac(fracStr: string): string {
-    const num = this.getFracAsNumber(fracStr);
-
-    // toFixed method has bugs on IE (0.7 --> 0)
-    return num.substr(2);
-  }
-
-  /**
-   */
-  static getFraction(number: string): string {
-    let fracStr = number.includes(".")
-      ? number.substring(number.indexOf(".") + 1)
-      : "";
-
-    fracStr = fracStr.replace(/\./, "");
-
-    return fracStr;
-  }
-
-  /**
-   */
-  getFracCorrectLength(frac: string): string {
-    let fracStr = frac;
-
-    if (fracStr.length > this.maxFrac) {
-      fracStr = this.getRoundedFrac(fracStr);
-    }
-
-    for (let i = fracStr.length; i < this.minFrac; i++) {
-      // if minFrac=4 then 1.12 --> 1.1200
-      fracStr = `${fracStr}0`;
-    }
-
-    while (
-      fracStr.length > this.minFrac &&
-      fracStr.charAt(fracStr.length - 1) === "0"
-    ) {
-      // if minInt=4 then 00034 --> 0034)
-      fracStr = fracStr.substring(0, fracStr.length - 1);
-    }
-
-    return fracStr;
-  }
-
-  /**
-   */
-  getInteger(number: string): string {
-    let intStr = number.includes(".")
-      ? number.substring(0, number.indexOf("."))
-      : number;
-
-    let doCarry = Number(this.getFracAsNumber(number)) > 1;
-    let i = intStr.length - 1;
-
-    while (doCarry) {
-      if (i === -1) {
-        intStr = `1${intStr}`;
-        break;
-      }
-
-      let x = intStr.charAt(i);
-      if (x === "9") {
-        x = "0";
-      } else {
-        x = `${x + 1}`;
-        doCarry = false;
-      }
-
-      intStr =
-        intStr.substring(0, i) + x + intStr.substring(i + 1, intStr.length);
-
-      i -= 1;
-    }
-
-    for (let j = intStr.length; j < this.minInt; j++) {
-      // if minInt=4 then 034 --> 0034
-      intStr = `0${intStr}`;
-    }
-
-    while (intStr.length > this.minInt && intStr.charAt(0) === "0") {
-      // if minInt=4 then 00034 --> 0034)
-      intStr = intStr.substring(1);
-    }
-
-    return intStr;
-  }
-
-  /**
-   */
-  addGrouping(intStr: string): string {
-    let groupedIntStr = intStr;
-
-    let j = 0;
-    for (let i = groupedIntStr.length; i > 0; i--) {
-      // add commas
-      if (j !== 0 && j % this.comma === 0) {
-        groupedIntStr = `${groupedIntStr.substring(
-          0,
-          i,
-        )},${groupedIntStr.substring(i)}`;
-        j = 0;
-      }
-
-      j += 1;
-    }
-
-    return groupedIntStr;
-  }
-
-  /**
-   */
-  getFormattedValue(
-    intStr: string,
-    fracStr: string,
-    isNegative: boolean,
-  ): string {
-    let formattedValue;
-    if (fracStr.length > 0)
-      formattedValue = `${this.prefix + intStr}.${fracStr}${this.suffix}`;
-    else formattedValue = this.prefix + intStr + this.suffix;
-
-    if (isNegative) {
-      formattedValue = `-${formattedValue}`;
-    }
-
-    return formattedValue;
-  }
-
-  /**
-   * Formats given value, using the pattern
-   * e.g. $#,###.00: 1223.06 --> $1,223.06
-   */
-  format(stringNumber: string = ""): string {
-    if (stringNumber === null) {
-      return "";
-    }
-
-    let formattedNumber = this.formatBack(stringNumber).toLowerCase();
-
-    if (isNaN(formattedNumber) || formattedNumber.length === 0) {
-      return stringNumber;
-    }
-
-    formattedNumber = DecimalFormat.scientificNumber(formattedNumber);
-    if (formattedNumber.includes("e")) {
-      return formattedNumber;
-    }
-
-    const isNegative = formattedNumber.charAt(0) === "-";
-    if (isNegative || formattedNumber.charAt(0) === "+") {
-      formattedNumber = formattedNumber.substring(1);
-    }
-
-    let fracStr = DecimalFormat.getFraction(formattedNumber);
-    let intStr = this.getInteger(formattedNumber);
-    if (this.isPercentage) {
-      // Add zeros behind fraction to make sure we have at least two characters and take first two character:
-      // 1 --> 100 --> 10
-      const addZeroToFrac = `${fracStr}00`.substr(0, 2);
-      // Add zeros in front of frac and get last two characters
-      const lastTwoFrac = `00${addZeroToFrac}`.substr(-2);
-
-      intStr = `${intStr}${lastTwoFrac}`;
-      fracStr = fracStr.substr(2);
-    }
-
-    fracStr = this.getFracCorrectLength(fracStr);
-
-    intStr = this.addGrouping(intStr);
-
-    return this.getFormattedValue(intStr, fracStr, isNegative);
-  }
-}
-
-export default DecimalFormat;