@beinformed/ui 1.65.29 → 2.0.0-beta.1

package/esm/utils/datetime/__tests__/DateTimeFormat.spec.js.flow

@@ -1,140 +0,0 @@
-import { TimestampUtil } from "../DateTimeUtil";
-import { INCLUDE_TIME_OFFSET, setSettings } from "../../../constants";
-
-const timestamp = "2023-06-07T07:04:01.010+02:00";
-
-describe("date time format conversion", () => {
-  beforeEach(() => {
-    TimestampUtil.setTimeZone("Europe/Amsterdam");
-    setSettings({ [INCLUDE_TIME_OFFSET]: true });
-  });
-
-  test("Year", () => {
-    expect(TimestampUtil.toFormat(timestamp, "yy")).toBe("23");
-    expect(TimestampUtil.toFormat(timestamp, "yyyy")).toBe("2023");
-  });
-
-  test("Month", () => {
-    expect(TimestampUtil.toFormat(timestamp, "M")).toBe("6");
-    expect(TimestampUtil.toFormat(timestamp, "MM")).toBe("06");
-    expect(TimestampUtil.toFormat(timestamp, "MMM")).toBe("Jun");
-    expect(TimestampUtil.toFormat(timestamp, "MMMM")).toBe("June");
-    expect(TimestampUtil.toFormat(timestamp, "MMMMM")).toBe("J");
-
-    expect(TimestampUtil.toFormat(timestamp, "L")).toBe("6");
-    expect(TimestampUtil.toFormat(timestamp, "LL")).toBe("06");
-    expect(TimestampUtil.toFormat(timestamp, "LLL")).toBe("Jun");
-    expect(TimestampUtil.toFormat(timestamp, "LLLL")).toBe("June");
-    expect(TimestampUtil.toFormat(timestamp, "LLLLL")).toBe("J");
-  });
-
-  test("Day", () => {
-    expect(TimestampUtil.toFormat(timestamp, "d")).toBe("7");
-    expect(TimestampUtil.toFormat(timestamp, "dd")).toBe("07");
-  });
-
-  test("Quarter", () => {
-    expect(TimestampUtil.toFormat(timestamp, "Q")).toBe("2");
-    expect(TimestampUtil.toFormat(timestamp, "QQ")).toBe("02");
-    expect(TimestampUtil.toFormat(timestamp, "QQQ")).toBe("Q2");
-    expect(TimestampUtil.toFormat(timestamp, "QQQQ")).toBe("2nd quarter");
-  });
-
-  test("Day of Week", () => {
-    expect(TimestampUtil.toFormat(timestamp, "E")).toBe("Wed");
-    expect(TimestampUtil.toFormat(timestamp, "EEEE")).toBe("Wednesday");
-    expect(TimestampUtil.toFormat(timestamp, "EEEEE")).toBe("W");
-
-    expect(TimestampUtil.toFormat(timestamp, "e")).toBe("3");
-    expect(TimestampUtil.toFormat(timestamp, "ee")).toBe("03");
-    expect(TimestampUtil.toFormat(timestamp, "eee")).toBe("Wed");
-    expect(TimestampUtil.toFormat(timestamp, "eeee")).toBe("Wednesday");
-    expect(TimestampUtil.toFormat(timestamp, "eeeee")).toBe("W");
-  });
-
-  test("Week", () => {
-    expect(TimestampUtil.toFormat(timestamp, "w")).toBe("23");
-    // expect(TimestampUtil.toFormat(timestamp, "W")).toBe("23");
-    // expect(TimestampUtil.toFormat(timestamp, "F")).toBe("W");
-  });
-
-  test("Hour", () => {
-    expect(TimestampUtil.toFormat(timestamp, "H")).toBe("7");
-    expect(TimestampUtil.toFormat(timestamp, "HH")).toBe("07");
-    expect(TimestampUtil.toFormat(timestamp, "h")).toBe("7");
-    expect(TimestampUtil.toFormat(timestamp, "hh")).toBe("07");
-
-    expect(TimestampUtil.toFormat(timestamp, "a")).toBe("AM");
-    expect(TimestampUtil.toFormat(timestamp, "aa")).toBe("AM");
-    expect(TimestampUtil.toFormat(timestamp, "aaa")).toBe("am");
-    expect(TimestampUtil.toFormat(timestamp, "aaaa")).toBe("a.m.");
-    expect(TimestampUtil.toFormat(timestamp, "aaaaa")).toBe("a");
-
-    expect(TimestampUtil.toFormat(timestamp, "K")).toBe("7");
-    expect(TimestampUtil.toFormat(timestamp, "k")).toBe("7");
-  });
-
-  test("Minute", () => {
-    expect(TimestampUtil.toFormat(timestamp, "m")).toBe("4");
-    expect(TimestampUtil.toFormat(timestamp, "mm")).toBe("04");
-  });
-
-  test("Seconds", () => {
-    expect(TimestampUtil.toFormat(timestamp, "s")).toBe("1");
-    expect(TimestampUtil.toFormat(timestamp, "ss")).toBe("01");
-  });
-
-  test("Milliseconds", () => {
-    expect(TimestampUtil.toFormat(timestamp, "SSS")).toBe("010");
-  });
-
-  test("Zone / offset", () => {
-    expect(TimestampUtil.toFormat(timestamp, "z")).toBe("GMT+2");
-    expect(TimestampUtil.toFormat(timestamp, "zz")).toBe("GMT+2");
-    expect(TimestampUtil.toFormat(timestamp, "zzz")).toBe("GMT+2");
-    expect(TimestampUtil.toFormat(timestamp, "zzzz")).toBe("GMT+02:00");
-    expect(TimestampUtil.toFormat(timestamp, "zzzzz")).toBe("GMT+02:00");
-
-    expect(TimestampUtil.toFormat(timestamp, "X")).toBe("+02");
-    expect(TimestampUtil.toFormat(timestamp, "XX")).toBe("+0200");
-    expect(TimestampUtil.toFormat(timestamp, "XXX")).toBe("+02:00");
-
-    expect(TimestampUtil.toFormat(timestamp, "x")).toBe("+02");
-    expect(TimestampUtil.toFormat(timestamp, "xx")).toBe("+0200");
-    expect(TimestampUtil.toFormat(timestamp, "xxx")).toBe("+02:00");
-
-    expect(TimestampUtil.toFormat(timestamp, "O")).toBe("GMT+2");
-    expect(TimestampUtil.toFormat(timestamp, "OOOO")).toBe("GMT+02:00");
-
-    // expect(TimestampUtil.toFormat(timestamp, "VV")).toBe("GMT+02:00");
-    // expect(TimestampUtil.toFormat(timestamp, "V")).toBe("Europe/Amsterdam");
-    // expect(TimestampUtil.toFormat(timestamp, "Z")).toBe("+02:00");
-    // expect(TimestampUtil.toFormat(timestamp, "ZZZZ")).toBe("+02:00");
-  });
-
-  test("Era and Chronology", () => {
-    expect(TimestampUtil.toFormat(timestamp, "G")).toBe("AD");
-    expect(TimestampUtil.toFormat(timestamp, "GGGG")).toBe("Anno Domini");
-    expect(TimestampUtil.toFormat(timestamp, "GGGGG")).toBe("A");
-
-    expect(TimestampUtil.toFormat(timestamp, "u")).toBe("2023");
-  });
-
-  test("Converted", () => {
-    const ZZZ = TimestampUtil.convertFormat("ZZZ");
-    expect(TimestampUtil.toFormat(timestamp, ZZZ)).toBe("+02:00");
-
-    const ZZ = TimestampUtil.convertFormat("ZZ");
-    expect(TimestampUtil.toFormat(timestamp, ZZ)).toBe("+0200");
-
-    const Z = TimestampUtil.convertFormat("Z");
-    expect(TimestampUtil.toFormat(timestamp, Z)).toBe("+02");
-
-    const fullDateTime = TimestampUtil.convertFormat(
-      "EEE MMM dd, yyyy h:mma ZZ",
-    );
-    expect(TimestampUtil.toFormat(timestamp, fullDateTime)).toBe(
-      "Wed Jun 07, 2023 7:04AM +0200",
-    );
-  });
-});

package/esm/utils/fetch/__mocks__/universalFetch.js.flow

@@ -1,38 +0,0 @@
-import applicationData from "./applicationData.json";
-import applicationContributions from "./applicationContributions.json";
-
-import formData from "./formData.json";
-import formContributions from "./formContributions.json";
-
-/**
- */
-const returnObject = (url) => {
-  switch (url) {
-    case "/BeInformed/contributions/persons/persons/createperson":
-      return formContributions;
-    case "/BeInformed/persons/persons/createperson":
-      return formData;
-    case "/BeInformed/contributions/":
-      return applicationContributions;
-    case "/BeInformed/":
-      return applicationData;
-    default:
-      return null;
-  }
-};
-
-/**
- */
-export default function universalFetch(args) {
-  return new Promise((resolve, reject) => {
-    process.nextTick(() => {
-      const data = returnObject(args.url);
-
-      if (data) {
-        return resolve(data);
-      }
-
-      return reject(new Error(`unknown: ${args.url}`));
-    });
-  });
-}

package/esm/utils/fetch/__tests__/xhr.spec.js.flow

@@ -1,281 +0,0 @@
-/* eslint-disable jest/no-conditional-expect */
-import xhr from "../xhr";
-
-import {
-  FetchException,
-  UnauthorizedException,
-  TimeoutException,
-  NotFoundException,
-  JsonParseException,
-  IllegalArgumentException,
-} from "../../../exceptions";
-import xhrMock from "xhr-mock";
-import Cache from "../../browser/Cache";
-
-const JSON_TYPE = "application/json";
-
-describe("xhr", () => {
-  // replace the real XHR object with the mock XHR object before each test
-  // eslint-disable-next-line jest/no-hooks
-  beforeEach(() => xhrMock.setup());
-
-  // put the real XHR object back and clear the mocks after each test
-  // eslint-disable-next-line jest/no-hooks
-  afterEach(() => xhrMock.teardown());
-
-  it("handles simple get requests", async () => {
-    expect.assertions(2);
-
-    xhrMock.get("/", (req, res) => {
-      expect(req.header("accept")).toBe(JSON_TYPE);
-      expect(req.header("Content-Type")).toBe(JSON_TYPE);
-
-      return res.status(200).body({ data: "ok" });
-    });
-
-    await xhr({ url: "/" });
-  });
-
-  it("should throw when nothing is set or url is missing", () => {
-    expect(() => xhr()).toThrow(IllegalArgumentException);
-    expect(() => xhr("/")).toThrow(IllegalArgumentException);
-    expect(() => xhr({})).toThrow(IllegalArgumentException);
-  });
-
-  it("adds encoded params to the url", async () => {
-    expect.assertions(2);
-
-    xhrMock.use("get", "/test?param1=one&param2=tw%C3%B6", (req, res) => {
-      const { path, query } = req.url();
-
-      expect(path).toBe("/test");
-      expect(query).toMatchObject({
-        param1: "one",
-        param2: "twö",
-      });
-
-      return res.status(200);
-    });
-
-    await xhr({
-      url: "/test",
-      params: "param1=one&param2=twö",
-    });
-  });
-
-  it("adds encoded params to a url with querystring", async () => {
-    expect.assertions(2);
-
-    xhrMock.use(
-      "get",
-      "/test?param1=one&param2=two&param3=thr%C3%A9%C3%AB",
-      (req, res) => {
-        const { path, query } = req.url();
-
-        expect(path).toBe("/test");
-        expect(query).toMatchObject({
-          param1: "one",
-          param2: "two",
-          param3: "thréë",
-        });
-
-        return res.status(200).body({});
-      },
-    );
-
-    await xhr({
-      url: "/test?param1=one",
-      params: "param2=two&param3=thréë",
-    });
-  });
-
-  it("handles json response", async () => {
-    expect.assertions(1);
-
-    xhrMock.get("/", {
-      status: 200,
-      body: {
-        type: "root",
-      },
-    });
-
-    await expect(xhr({ url: "/" })).resolves.toStrictEqual({ type: "root" });
-  });
-
-  it("return JsonParseException when response is not valid json and responseType is text", async () => {
-    expect.assertions(1);
-
-    xhrMock.get("/", {
-      status: 200,
-      headers: {
-        "Content-Type": JSON_TYPE,
-      },
-      body: "root",
-    });
-
-    await expect(() => xhr({ url: "/", responseType: "text" })).rejects.toThrow(
-      JsonParseException,
-    );
-  });
-
-  it("can handle modular ui form responses", async () => {
-    expect.assertions(1);
-
-    xhrMock.post("/form", {
-      status: 400,
-      body: {
-        formresponse: {
-          form: "response",
-        },
-      },
-    });
-
-    const response = await xhr({ url: "/form", method: "post", data: "{}" });
-    expect(response).toStrictEqual({ formresponse: { form: "response" } });
-  });
-
-  it("can handle progress events", async () => {
-    expect.assertions(1);
-
-    xhrMock.post("/", {
-      status: 200,
-      headers: {
-        "Content-Length": "12",
-      },
-      body: "Hello world!",
-    });
-
-    const progressEvents = new Promise((resolve) => {
-      const events = [];
-
-      xhr({
-        url: "/",
-        method: "post",
-        /**
-         */
-        onProgress: ({ type, loaded, total, lengthComputable }) => {
-          events.push({ type, loaded, total, lengthComputable });
-
-          // eslint-disable-next-line jest/no-conditional-in-test
-          if (type === "loadend") {
-            resolve(events);
-          }
-        },
-        data: "Upload data",
-        headers: {
-          "Content-Length": "11",
-        },
-      });
-    });
-
-    await expect(progressEvents).resolves.toStrictEqual([
-      {
-        type: "loadstart",
-        lengthComputable: false,
-        loaded: 0,
-        total: 0,
-      },
-      {
-        type: "progress",
-        lengthComputable: true,
-        loaded: 12,
-        total: 12,
-      },
-      {
-        type: "load",
-        lengthComputable: true,
-        loaded: 12,
-        total: 12,
-      },
-      {
-        type: "loadend",
-        lengthComputable: true,
-        loaded: 12,
-        total: 12,
-      },
-    ]);
-  });
-
-  it("handles error response", async () => {
-    expect.assertions(3);
-    xhrMock.get("/", {
-      status: 500,
-      reason: "Internal Server Error",
-      body: {
-        error: {
-          id: "Error.GeneralError",
-        },
-      },
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(FetchException);
-      expect(error.status).toBe(500);
-      expect(error.id).toBe("Error.GeneralError");
-    });
-  });
-
-  it("handles not found response", async () => {
-    expect.assertions(3);
-    xhrMock.get("/", {
-      status: 404,
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(NotFoundException);
-      expect(error.status).toBe(404);
-      expect(error.id).toBe("NotFoundException");
-    });
-  });
-
-  it("handles unauthorized response", async () => {
-    expect.assertions(3);
-    xhrMock.get("/", {
-      status: 401,
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(UnauthorizedException);
-      expect(error.status).toBe(401);
-      expect(error.id).toBe("UnauthorizedException");
-    });
-  });
-
-  it("handles unauthorized and unexpected response", async () => {
-    expect.assertions(1);
-    xhrMock.get("/", {
-      status: 401,
-      body: {
-        has: "body?",
-      },
-    });
-
-    await xhr({ url: "/" }).catch((error) => {
-      expect(error).toBeInstanceOf(UnauthorizedException);
-    });
-  });
-
-  it("handles basic authentication", async () => {
-    expect.assertions(1);
-
-    xhrMock.get("/", (req, res) => {
-      expect(req.header("Authorization")).toBe("Basic abcdef");
-      return res.status(200);
-    });
-
-    Cache.addItem("basic", "abcdef");
-
-    await xhr({ url: "/" });
-  });
-
-  it("handles timeouts", async () => {
-    expect.assertions(2);
-
-    xhrMock.get("/", () => new Promise(() => undefined));
-
-    await xhr({ url: "/", timeout: 2000 }).catch((error) => {
-      expect(error).toBeInstanceOf(TimeoutException);
-      expect(error.name).toBe("TimeoutException");
-    });
-  });
-});

package/esm/utils/fetch/serverFetch.js

@@ -1,25 +0,0 @@
-import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
-import _Promise from "@babel/runtime-corejs3/core-js-stable/promise";
-import { getBasePath } from "../../constants/Settings";
-import { FetchException } from "../../exceptions";
-/**
- * Fetch data from server (uses nashorn and datafetcher).
- */
-export default function serverFetch(args) {
-  var _context;
-  // remove contextPath of url, when the request is internal the context path is not needed
-  const urlNoBase = _includesInstanceProperty(_context = args.url).call(_context, "http") ? args.url : args.url.replace(getBasePath(), "");
-  const params = args.params ? args.params.replace("includeContext=true", "") : "";
-  const url = params === "" ? urlNoBase : `${urlNoBase}?${params}`;
-  const data = dataFetcher.fetch(url, args);
-  try {
-    const jsonData = JSON.parse(data);
-    if (jsonData.error) {
-      return _Promise.reject(new FetchException(jsonData, null, args));
-    }
-    return _Promise.resolve(jsonData);
-  } catch (error) {
-    return _Promise.reject(error);
-  }
-}
-//# sourceMappingURL=serverFetch.js.map

package/esm/utils/fetch/serverFetch.js.flow

@@ -1,33 +0,0 @@
-// @flow
-import { getBasePath } from "../../constants/Settings";
-import { FetchException } from "../../exceptions";
-
-import type { RequestOptions } from "./types";
-
-/**
- * Fetch data from server (uses nashorn and datafetcher).
- */
-export default function serverFetch(args: RequestOptions): Promise<any> {
-  // remove contextPath of url, when the request is internal the context path is not needed
-  const urlNoBase = args.url.includes("http")
-    ? args.url
-    : args.url.replace(getBasePath(), "");
-  const params = args.params
-    ? args.params.replace("includeContext=true", "")
-    : "";
-  const url = params === "" ? urlNoBase : `${urlNoBase}?${params}`;
-
-  const data = dataFetcher.fetch(url, args);
-
-  try {
-    const jsonData = JSON.parse(data);
-
-    if (jsonData.error) {
-      return Promise.reject(new FetchException(jsonData, null, args));
-    }
-
-    return Promise.resolve(jsonData);
-  } catch (error) {
-    return Promise.reject(error);
-  }
-}

package/esm/utils/fetch/serverFetch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serverFetch.js","names":["getBasePath","FetchException","serverFetch","args","_context","urlNoBase","_includesInstanceProperty","url","call","replace","params","data","dataFetcher","fetch","jsonData","JSON","parse","error","_Promise","reject","resolve"],"sources":["../../../src/utils/fetch/serverFetch.js"],"sourcesContent":["// @flow\nimport { getBasePath } from \"../../constants/Settings\";\nimport { FetchException } from \"../../exceptions\";\n\nimport type { RequestOptions } from \"./types\";\n\n/**\n * Fetch data from server (uses nashorn and datafetcher).\n */\nexport default function serverFetch(args: RequestOptions): Promise<any> {\n  // remove contextPath of url, when the request is internal the context path is not needed\n  const urlNoBase = args.url.includes(\"http\")\n    ? args.url\n    : args.url.replace(getBasePath(), \"\");\n  const params = args.params\n    ? args.params.replace(\"includeContext=true\", \"\")\n    : \"\";\n  const url = params === \"\" ? urlNoBase : `${urlNoBase}?${params}`;\n\n  const data = dataFetcher.fetch(url, args);\n\n  try {\n    const jsonData = JSON.parse(data);\n\n    if (jsonData.error) {\n      return Promise.reject(new FetchException(jsonData, null, args));\n    }\n\n    return Promise.resolve(jsonData);\n  } catch (error) {\n    return Promise.reject(error);\n  }\n}\n"],"mappings":";;AACA,SAASA,WAAW,QAAQ,0BAA0B;AACtD,SAASC,cAAc,QAAQ,kBAAkB;AAIjD;AACA;AACA;AACA,eAAe,SAASC,WAAWA,CAACC,IAAoB,EAAgB;EAAA,IAAAC,QAAA;EACtE;EACA,MAAMC,SAAS,GAAGC,yBAAA,CAAAF,QAAA,GAAAD,IAAI,CAACI,GAAG,EAAAC,IAAA,CAAAJ,QAAA,EAAU,MAAM,CAAC,GACvCD,IAAI,CAACI,GAAG,GACRJ,IAAI,CAACI,GAAG,CAACE,OAAO,CAACT,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC;EACvC,MAAMU,MAAM,GAAGP,IAAI,CAACO,MAAM,GACtBP,IAAI,CAACO,MAAM,CAACD,OAAO,CAAC,qBAAqB,EAAE,EAAE,CAAC,GAC9C,EAAE;EACN,MAAMF,GAAG,GAAGG,MAAM,KAAK,EAAE,GAAGL,SAAS,GAAG,GAAGA,SAAS,IAAIK,MAAM,EAAE;EAEhE,MAAMC,IAAI,GAAGC,WAAW,CAACC,KAAK,CAACN,GAAG,EAAEJ,IAAI,CAAC;EAEzC,IAAI;IACF,MAAMW,QAAQ,GAAGC,IAAI,CAACC,KAAK,CAACL,IAAI,CAAC;IAEjC,IAAIG,QAAQ,CAACG,KAAK,EAAE;MAClB,OAAOC,QAAA,CAAQC,MAAM,CAAC,IAAIlB,cAAc,CAACa,QAAQ,EAAE,IAAI,EAAEX,IAAI,CAAC,CAAC;IACjE;IAEA,OAAOe,QAAA,CAAQE,OAAO,CAACN,QAAQ,CAAC;EAClC,CAAC,CAAC,OAAOG,KAAK,EAAE;IACd,OAAOC,QAAA,CAAQC,MAAM,CAACF,KAAK,CAAC;EAC9B;AACF","ignoreList":[]}

package/esm/utils/fetch/types.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.js.map

package/esm/utils/fetch/types.js.flow

@@ -1,46 +0,0 @@
-// @flow
-import typeof { HTTP_METHODS } from "../../constants/Constants";
-import type { ModularUIModel } from "../../models/types";
-import type { TargetModel } from "../../modularui/types";
-
-export type RequestURLOptions = {
-  url: string,
-};
-
-export type RequestBaseOptions = {
-  origin?: string,
-  contextPath?: string,
-  method?: $Keys<HTTP_METHODS>,
-  params?: string,
-  data?: any,
-  timeout?: number,
-  responseType?: string,
-  headers?: {
-    [headerName: string]: string,
-    Accept?: string,
-    "Accept-Language"?: string,
-    "Content-Type"?: string,
-    "x-filename"?: string,
-    "x-filesize"?: string,
-  },
-  events?: { [eventName: string]: () => void },
-  onProgress?: ProgressEventHandler,
-  includeContext?: boolean,
-  locale?: string,
-  cache?: boolean,
-  isReload?: boolean,
-  withCredentials?: boolean,
-};
-
-export type RequestOptions = { ...RequestURLOptions, ...RequestBaseOptions };
-
-export type UpdateHandler = (newModel: ModularUIModel) => ModularUIModel;
-export type RequestModularUIOptions = {
-  ...RequestBaseOptions,
-  targetModel?: TargetModel,
-  forceTargetModel?: boolean,
-  updateHandler?: UpdateHandler | void,
-  childmodels?: boolean,
-  isValidationRequest?: boolean,
-  removeOnUnmount?: boolean,
-};

package/esm/utils/fetch/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../src/utils/fetch/types.js"],"sourcesContent":["// @flow\nimport typeof { HTTP_METHODS } from \"../../constants/Constants\";\nimport type { ModularUIModel } from \"../../models/types\";\nimport type { TargetModel } from \"../../modularui/types\";\n\nexport type RequestURLOptions = {\n  url: string,\n};\n\nexport type RequestBaseOptions = {\n  origin?: string,\n  contextPath?: string,\n  method?: $Keys<HTTP_METHODS>,\n  params?: string,\n  data?: any,\n  timeout?: number,\n  responseType?: string,\n  headers?: {\n    [headerName: string]: string,\n    Accept?: string,\n    \"Accept-Language\"?: string,\n    \"Content-Type\"?: string,\n    \"x-filename\"?: string,\n    \"x-filesize\"?: string,\n  },\n  events?: { [eventName: string]: () => void },\n  onProgress?: ProgressEventHandler,\n  includeContext?: boolean,\n  locale?: string,\n  cache?: boolean,\n  isReload?: boolean,\n  withCredentials?: boolean,\n};\n\nexport type RequestOptions = { ...RequestURLOptions, ...RequestBaseOptions };\n\nexport type UpdateHandler = (newModel: ModularUIModel) => ModularUIModel;\nexport type RequestModularUIOptions = {\n  ...RequestBaseOptions,\n  targetModel?: TargetModel,\n  forceTargetModel?: boolean,\n  updateHandler?: UpdateHandler | void,\n  childmodels?: boolean,\n  isValidationRequest?: boolean,\n  removeOnUnmount?: boolean,\n};\n"],"mappings":"","ignoreList":[]}

package/esm/utils/fetch/universalFetch.js

@@ -1,86 +0,0 @@
-import _Promise from "@babel/runtime-corejs3/core-js-stable/promise";
-import { IS_SYNC } from "../../constants/Constants";
-import { cacheContributions } from "../../constants";
-import serverFetch from "./serverFetch";
-import xhr from "./xhr";
-import Cache from "../browser/Cache";
-const IS_FETCHING = "is-fetching";
-
-/**
- * Checks each x ms if a cache item is set after fetching the item.
- * @private
- */
-const waitForCachedItem = cacheKey => {
-  let TIMEOUT = 3000;
-  const CHECK_TIMEOUT = 100;
-  return new _Promise((resolve, reject) => {
-    const check = () => {
-      if (Cache.getItem(cacheKey) !== IS_FETCHING) {
-        const cachedItem = Cache.getItem(cacheKey);
-        if (cachedItem != null) {
-          resolve(cachedItem);
-        } else {
-          reject(new Error("Empty cached item"));
-        }
-      } else if (TIMEOUT <= 0) {
-        reject(new Error("Empty cached item"));
-      } else {
-        TIMEOUT = TIMEOUT - CHECK_TIMEOUT;
-        setTimeout(check, CHECK_TIMEOUT);
-      }
-    };
-    setTimeout(check, CHECK_TIMEOUT);
-  });
-};
-
-/**
- * @private
- */
-const browserFetch = args => {
-  const shouldCache = cacheContributions() && args.cache;
-  if (shouldCache) {
-    const cacheKey = Cache.createResourceKey(args);
-    if (Cache.hasItem(cacheKey)) {
-      const cacheItem = Cache.getItem(cacheKey);
-      if (cacheItem === IS_FETCHING) {
-        return waitForCachedItem(cacheKey);
-      }
-      if (cacheItem != null) {
-        return _Promise.resolve(cacheItem);
-      }
-    }
-    Cache.addItem(cacheKey, IS_FETCHING);
-  }
-  return xhr(args).then(response => {
-    if (shouldCache) {
-      const cacheKey = Cache.createResourceKey(args);
-      Cache.addItem(cacheKey, response);
-    }
-    return response;
-  });
-};
-
-/**
- * Request data from server, uses server datafetcher or xhr in browser.
- */
-const universalFetch = args => {
-  // Set locale as Accept-Language header
-  if (args.locale) {
-    // $FlowFixMe
-    args.headers = {
-      ...args.headers,
-      "Accept-Language": args.locale
-    };
-  }
-  if (args.includeContext) {
-    args.url = `${args.url}?includeContext=true`;
-  }
-
-  // server side no access to the browser cache apis, no cache available
-  if (IS_SYNC) {
-    return serverFetch(args);
-  }
-  return browserFetch(args);
-};
-export default universalFetch;
-//# sourceMappingURL=universalFetch.js.map