@beinformed/ui 1.65.12 → 1.65.14

package/src/react-server/__tests__/requestInformation.spec.js

@@ -1,266 +0,0 @@
-import {
-  getFullRequestUrl,
-  getFullRequestHref,
-  getCookieFromRequest,
-  getPreferredLocale,
-} from "../requestInformation"; // Adjust path as needed
-
-// Mock the Href class
-const mockHref = jest.fn((url) => ({
-  url: url, // For easy inspection in tests
-  // You can add other Href methods here if they are used by your functions
-  toString: () => url,
-}));
-jest.mock("../../models/href/Href", () => {
-  return jest.fn().mockImplementation((url) => {
-    return new mockHref(url);
-  });
-});
-
-// Mock the Locales class
-const mockLocales = {
-  availableLocaleCodes: ["en-US", "es-ES", "fr-FR"],
-  getPreferredLocale: jest.fn((header) => {
-    if (header.includes("en")) return "en-US";
-    if (header.includes("es")) return "es-ES";
-    if (header.includes("fr")) return "fr-FR";
-    return mockLocales.availableLocaleCodes[0]; // Default if no match
-  }),
-};
-jest.mock("../../i18n/Locales", () => {
-  return jest.fn().mockImplementation(() => {
-    return mockLocales;
-  });
-});
-
-// Helper function to create a mock HttpServletRequestJava object
-const createMockRequest = ({
-  pathInfo = null,
-  queryString = null,
-  cookies = [],
-  headers = {},
-} = {}) => ({
-  getPathInfo: jest.fn(() => pathInfo),
-  getQueryString: jest.fn(() => queryString),
-  getCookieByName: jest.fn((name) => {
-    const cookie = cookies.find((c) => c.name === name);
-    return cookie ? cookie.value : null;
-  }),
-  getHeader: jest.fn((name) => headers[name.toLowerCase()] || null),
-});
-
-describe("requestInformation", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // Reset mock Href to its initial mock implementation
-    // This is important if you test multiple instantiations or interactions
-    // with the Href mock.
-    require("../../models/href/Href").mockClear();
-    require("../../models/href/Href").mockImplementation((url) => {
-      return new mockHref(url);
-    });
-  });
-
-  describe("getFullRequestUrl", () => {
-    it("should return the path info when no query string is present", () => {
-      const request = createMockRequest({
-        pathInfo: "/some/path",
-      });
-      expect(getFullRequestUrl(request)).toBe("/some/path");
-      expect(request.getPathInfo).toHaveBeenCalledTimes(1);
-      expect(request.getQueryString).toHaveBeenCalledTimes(1);
-    });
-
-    it("should return the path info with a leading slash if pathInfo is null", () => {
-      const request = createMockRequest({
-        pathInfo: null,
-      });
-      expect(getFullRequestUrl(request)).toBe("/");
-    });
-
-    it("should return the path info with a leading slash if pathInfo is an empty string", () => {
-      const request = createMockRequest({
-        pathInfo: "",
-      });
-      expect(getFullRequestUrl(request)).toBe("/");
-    });
-
-    it("should return the path info with an encoded query string", () => {
-      const request = createMockRequest({
-        pathInfo: "/search",
-        queryString: "q=hello world&filter=test",
-      });
-      expect(getFullRequestUrl(request)).toBe(
-        "/search?q=hello+world&filter=test",
-      );
-    });
-
-    it("should handle special characters in pathInfo by encoding them", () => {
-      const request = createMockRequest({
-        pathInfo: "/path with spaces/and<script>alert(1)</script>",
-      });
-      expect(getFullRequestUrl(request)).toBe(
-        "/path%20with%20spaces/and%3Cscript%3Ealert(1)%3C/script%3E",
-      );
-    });
-
-    it("should handle path info with multiple segments and special characters", () => {
-      const request = createMockRequest({
-        pathInfo: "/product/category/item with special chars & numbers/id-123",
-      });
-      expect(getFullRequestUrl(request)).toBe(
-        "/product/category/item%20with%20special%20chars%20%26%20numbers/id-123",
-      );
-    });
-
-    it("should correctly encode both path and query string with special characters", () => {
-      const request = createMockRequest({
-        pathInfo: "/api/data",
-        queryString: "name=John Doe & email=john@example.com",
-      });
-      expect(getFullRequestUrl(request)).toBe(
-        "/api/data?name=John+Doe+&+email=john%40example.com",
-      );
-    });
-
-    it("should handle an empty query string (not null) gracefully", () => {
-      const request = createMockRequest({
-        pathInfo: "/home",
-        queryString: "",
-      });
-      expect(getFullRequestUrl(request)).toBe("/home");
-    });
-  });
-
-  describe("getFullRequestHref", () => {
-    it("should return an Href instance with the full request URL", () => {
-      const request = createMockRequest({
-        pathInfo: "/products",
-        queryString: "id=123",
-      });
-      const hrefInstance = getFullRequestHref(request);
-
-      // Verify that Href constructor was called with the correct URL
-      expect(require("../../models/href/Href")).toHaveBeenCalledTimes(1);
-      expect(require("../../models/href/Href")).toHaveBeenCalledWith(
-        "/products?id=123",
-      );
-
-      // Verify the returned object is an instance of the mock Href
-      expect(hrefInstance.url).toBe("/products?id=123");
-    });
-
-    it("should handle complex URLs and pass them to Href", () => {
-      const request = createMockRequest({
-        pathInfo: "/search/results",
-        queryString:
-          "q=javascript%20xss&param=value&multi=option%201%2Coption2,option3",
-      });
-      const hrefInstance = getFullRequestHref(request);
-      expect(require("../../models/href/Href")).toHaveBeenCalledWith(
-        "/search/results?q=javascript+xss&param=value&multi=option+1%2Coption2%2Coption3",
-      );
-      expect(hrefInstance.url).toBe(
-        "/search/results?q=javascript+xss&param=value&multi=option+1%2Coption2%2Coption3",
-      );
-    });
-  });
-
-  describe("getCookieFromRequest", () => {
-    it("should return the cookie value if found", () => {
-      const request = createMockRequest({
-        cookies: [
-          {
-            name: "session_id",
-            value: "abc123xyz",
-          },
-        ],
-      });
-      expect(getCookieFromRequest(request, "session_id")).toBe("abc123xyz");
-      expect(request.getCookieByName).toHaveBeenCalledWith("session_id");
-    });
-
-    it("should return null if the cookie is not found", () => {
-      const request = createMockRequest({
-        cookies: [
-          {
-            name: "other_cookie",
-            value: "value",
-          },
-        ],
-      });
-      expect(getCookieFromRequest(request, "non_existent_cookie")).toBeNull();
-      expect(request.getCookieByName).toHaveBeenCalledWith(
-        "non_existent_cookie",
-      );
-    });
-
-    it("should handle empty cookies array", () => {
-      const request = createMockRequest({
-        cookies: [],
-      });
-      expect(getCookieFromRequest(request, "any_cookie")).toBeNull();
-    });
-  });
-
-  describe("getPreferredLocale", () => {
-    it("should return locale from cookie if present", () => {
-      const request = createMockRequest({
-        cookies: [
-          {
-            name: "locale",
-            value: "es-ES",
-          },
-        ],
-        headers: {
-          "accept-language": "en-US,en;q=0.9",
-        },
-      });
-      const locales = mockLocales; // Using the mocked locales directly for convenience
-      expect(getPreferredLocale(request, locales)).toBe("es-ES");
-      expect(locales.getPreferredLocale).toHaveBeenCalledWith("es-ES"); // Because cookie took precedence
-    });
-
-    it("should return the first available locale code if no cookie and no Accept-Language header", () => {
-      const request = createMockRequest({}); // No cookies, no headers
-      const locales = mockLocales;
-      expect(getPreferredLocale(request, locales)).toBe("en-US");
-      expect(locales.getPreferredLocale).not.toHaveBeenCalled();
-    });
-
-    it("should handle null Accept-Language header correctly", () => {
-      const request = createMockRequest({
-        headers: {
-          "accept-language": null,
-        },
-      }); // Explicitly null header
-      const locales = mockLocales;
-      expect(getPreferredLocale(request, locales)).toBe("en-US");
-      expect(locales.getPreferredLocale).not.toHaveBeenCalled();
-    });
-
-    it("should handle empty string Accept-Language header correctly", () => {
-      const request = createMockRequest({
-        headers: {
-          "accept-language": "",
-        },
-      }); // Explicitly empty header
-      const locales = mockLocales;
-      expect(getPreferredLocale(request, locales)).toBe("en-US");
-      expect(locales.getPreferredLocale).not.toHaveBeenCalled();
-    });
-
-    it("should call getCookieFromRequest and getHeader", () => {
-      const request = createMockRequest({
-        headers: {
-          "accept-language": "de-DE",
-        },
-      });
-      const locales = mockLocales;
-      getPreferredLocale(request, locales);
-      expect(request.getCookieByName).toHaveBeenCalledWith("locale");
-      expect(request.getHeader).toHaveBeenCalledWith("Accept-Language");
-    });
-  });
-});

package/src/react-server/__tests__/serverUtil.spec.js

@@ -1,183 +0,0 @@
-import configureMockStore from "redux-mock-store";
-
-import {
-  setServerPreferences,
-  setI18n,
-  setConfigurationTheme,
-} from "../serverUtil";
-import { IllegalArgumentException } from "../../exceptions";
-
-import { availableLocales, Locales } from "../../i18n";
-
-global.preferencesProvider = {
-  getPreferenceByName: jest.fn(),
-  getLayoutConfigFileLocation: () => "/theme",
-};
-
-const mockStore = configureMockStore();
-
-const getExpectedLocales = () =>
-  new Locales([
-    ...availableLocales.map((locale) =>
-      locale.code === "nl"
-        ? {
-            ...locale,
-            messages: {
-              message_nl: "Dutch message",
-            },
-          }
-        : locale,
-    ),
-  ]);
-
-describe("serverUtil", () => {
-  it("handles setI18n", () => {
-    const store = mockStore({ i18n: {} });
-
-    expect(() => setI18n(store)).toThrow(IllegalArgumentException);
-    expect(() => setI18n(store, "bla")).toThrow(IllegalArgumentException);
-
-    setI18n(
-      store,
-      [
-        {
-          code: "nl",
-          messages: {
-            message_nl: "Dutch message",
-          },
-        },
-      ],
-      {
-        getHeader: () => "",
-        getCookieByName: () => "",
-      },
-    );
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SET_LOCALES",
-        payload: {
-          locale: "en",
-          locales: getExpectedLocales(),
-        },
-      },
-    ]);
-  });
-
-  it("setConfigurationTheme", () => {
-    global.dataFetcher = {
-      fetch: () => '{ "prop": "value" }',
-    };
-
-    const store = mockStore({ preferences: {} });
-
-    setConfigurationTheme(store);
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          theme: {
-            prop: "value",
-          },
-        },
-      },
-    ]);
-  });
-
-  it("setServerPreferences by array of strings", () => {
-    const store = mockStore({ preferences: {} });
-
-    setServerPreferences(store, ["prefA", "prefB"]);
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          prefA: null,
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          prefB: null,
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          hasAllContentInData: false,
-        },
-      },
-      {
-        type: "SET_PREFERENCES",
-        payload: {
-          "FormClient.login_url": "/callback?client_name=FormClient",
-          "FormClient.logout_url": "/logout",
-          "FormClient.password_field_name": "j_password",
-          "FormClient.username_field_name": "j_username",
-          "security.clients": null,
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          isIncludeTimeOffsetInDateTimes: false,
-        },
-      },
-    ]);
-  });
-
-  it("setServerPreferences by array of objects", () => {
-    const store = mockStore({ preferences: {} });
-
-    setServerPreferences(store, [
-      { name: "prefA", defaultValue: "defaultA" },
-      { name: "prefB", defaultValue: "defaultB, defaultB2" },
-      { name: "prefC", defaultValue: "defaultC, defaultC2", type: "string" },
-    ]);
-
-    expect(store.getActions()).toStrictEqual([
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          prefA: "defaultA",
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          prefB: ["defaultB", "defaultB2"],
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          prefC: "defaultC, defaultC2",
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          hasAllContentInData: false,
-        },
-      },
-      {
-        type: "SET_PREFERENCES",
-        payload: {
-          "FormClient.login_url": "/callback?client_name=FormClient",
-          "FormClient.logout_url": "/logout",
-          "FormClient.password_field_name": "j_password",
-          "FormClient.username_field_name": "j_username",
-          "security.clients": null,
-        },
-      },
-      {
-        type: "SET_PREFERENCE",
-        payload: {
-          isIncludeTimeOffsetInDateTimes: false,
-        },
-      },
-    ]);
-  });
-});

package/src/react-server/contextPath.js

@@ -1,8 +0,0 @@
-// @flow
-import { getBasePath } from "../constants/Settings";
-
-(function x() {
-  __webpack_public_path__ = `${getBasePath()}/`; // NOSONAR
-})();
-
-export {};

package/src/react-server/createSSRComplete.js

@@ -1,63 +0,0 @@
-// @flow
-import { MODULARUI_STATUS } from "../constants/Constants";
-
-import type { ReduxStore, ReduxState } from "../redux/types";
-
-/**
- */
-const noLoading = (state: ReduxState) =>
-  Object.keys(state.modularui).filter(
-    (key) => state.modularui[key].status === MODULARUI_STATUS.LOADING,
-  ).length === 0;
-
-/**
- */
-const loadingCounter = (state: ReduxState) =>
-  Object.keys(state.modularui).filter(
-    (key) => state.modularui[key].status === MODULARUI_STATUS.LOADING,
-  ).length;
-
-/**
- */
-const createSSRComplete = (
-  store: ReduxStore,
-  render: Function,
-): Promise<string> => {
-  let loadingCount = loadingCounter(store.getState());
-  let html = "<div>Nothing to render</div>";
-
-  return new Promise((resolve, reject) => {
-    const unsubscribe = store.subscribe(() => {
-      const previousCount = loadingCount;
-      loadingCount = loadingCounter(store.getState());
-
-      if (previousCount !== loadingCount && noLoading(store.getState())) {
-        try {
-          html = render();
-        } catch (error) {
-          reject(error);
-          return;
-        }
-
-        if (noLoading(store.getState())) {
-          unsubscribe();
-          resolve(html);
-        }
-      }
-    });
-
-    try {
-      html = render();
-    } catch (error) {
-      reject(error);
-      return;
-    }
-
-    if (noLoading(store.getState())) {
-      unsubscribe();
-      resolve(html);
-    }
-  });
-};
-
-export default createSSRComplete;

package/src/react-server/htmlpage.js

@@ -1,55 +0,0 @@
-// @flow
-import { IllegalArgumentException } from "../exceptions";
-
-export type TemplateProps = {
-  contextPath: string,
-  html: string,
-  head: Object,
-  state: string,
-  UUID: string,
-};
-
-/**
- */
-const htmlpage = (props: TemplateProps): string => {
-  if (props?.contextPath === undefined) {
-    throw new IllegalArgumentException("Missing contextPath argument");
-  }
-  if (props.html === undefined) {
-    throw new IllegalArgumentException("Missing html for server");
-  }
-
-  const { head = {} } = props;
-
-  const template = `
-  <!doctype html>
-  <html ${head.htmlAttributes ? head.htmlAttributes.toString() : ""}>
-    <head>
-      <meta charset="utf-8" />
-      ${Object.keys(head)
-        .filter((key) => key !== "htmlAttributes")
-        .map((key) => head[key].toString())
-        .join("")}
-      {CSSASSETS:<link rel="stylesheet" type="text/css" href="{CONTEXT_PATH}/{FILE}" />:CSSASSETS}
-    </head>
-    <body class="nojs">
-      <div id="application">${props.html}</div>
-      <div id="portal"></div>
-      <script
-        type="application/json"
-        data-app-state="app-json"
-        data-app-contextpath="{CONTEXT_PATH}"
-        data-app-filepath="{FILEPATH}"
-        data-app-nonce="${props.UUID ?? ""}">${props.state ?? ""}</script>
-      {JSASSETS:<script src="{CONTEXT_PATH}/{FILE}"></script>:JSASSETS}
-    </body>
-  </html>
-`;
-
-  // It is important to replace the context afterwards,
-  // the JSASSESTS and CSSASSETS parts act as a small template for all generated javascript and css files
-  // these templates must be pure strings to make it possible to add the context path in all situations
-  return template.replace(/{CONTEXT_PATH}/g, props.contextPath).trim();
-};
-
-export default htmlpage;

package/src/react-server/index.js

@@ -1,13 +0,0 @@
-// @flow
-export { setCustomErrorResponseHandler } from "../redux/actions/Error";
-
-export { default as renderSSRComplete } from "./renderSSRComplete";
-export { default as renderSSRMinimal } from "./renderSSRMinimal";
-
-export { default as serverNoSSR } from "./serverNoSSR";
-export { default as serverSSR } from "./serverSSR";
-
-export { default as htmlpage } from "./htmlpage";
-
-export * from "./requestInformation";
-export * from "./serverUtil";

package/src/react-server/renderSSRComplete.js

@@ -1,111 +0,0 @@
-// @flow
-import { renderToString } from "react-dom/server";
-import { Provider } from "react-redux";
-import { StaticRouter as Router } from "react-router";
-
-import { HelmetProvider } from "react-helmet-async";
-
-import { ServerStyleSheet, StyleSheetManager } from "styled-components";
-
-import createSSRComplete from "./createSSRComplete";
-import htmlpage from "./htmlpage";
-
-import { getBasePathServer } from "../constants/Settings";
-
-import ThemeProvider from "../react-theme/ThemeProvider";
-import ErrorBoundary from "../react/ErrorBoundary";
-
-import { createHead, handleErrors, dehydrate } from "./serverUtil";
-
-import type { Theme } from "../react-theme/types";
-import type { ReduxStore } from "../redux/types";
-import type Href from "../models/href/Href";
-import type { TemplateProps } from "./htmlpage";
-import type { Location } from "react-router";
-
-type Props = {
-  store: ReduxStore,
-  theme: Theme,
-  UUID: string,
-  requestHref: Href,
-  render: Function,
-  ErrorPage: any,
-  template?: (TemplateProps) => string,
-};
-/**
- */
-const renderSSRComplete = ({
-  store,
-  theme,
-  UUID = "",
-  requestHref,
-  render,
-  ErrorPage,
-  template = htmlpage,
-}: Props): Promise<string> => {
-  const helmetContext = { helmet: {} };
-  const routerContext = {};
-
-  const sheet = new ServerStyleSheet();
-
-  // $FlowFixMe[incompatible-type]
-  // $FlowFixMe[prop-missing]
-  const location: Location = requestHref.toLocation();
-
-  const basePath = getBasePathServer();
-
-  return createSSRComplete(store, () =>
-    renderToString(
-      <Provider store={store}>
-        <StyleSheetManager sheet={sheet.instance}>
-          <ThemeProvider theme={theme}>
-            <HelmetProvider context={helmetContext}>
-              <ErrorBoundary>
-                <Router
-                  basename={basePath}
-                  location={location}
-                  context={routerContext}
-                >
-                  {render()}
-                </Router>
-              </ErrorBoundary>
-            </HelmetProvider>
-          </ThemeProvider>
-        </StyleSheetManager>
-      </Provider>,
-    ),
-  )
-    .then((appHTML) => {
-      handleErrors(store);
-      const head = createHead(sheet, UUID, helmetContext);
-      return template({
-        contextPath: basePath,
-        html: appHTML,
-        head,
-        state: dehydrate(store),
-        UUID,
-      });
-    })
-    .catch((error) =>
-      template({
-        contextPath: basePath,
-        html: renderToString(
-          <StyleSheetManager sheet={sheet.instance}>
-            <ThemeProvider theme={theme}>
-              <ErrorPage
-                errorMessage={error.message}
-                errorResource={error.fileName}
-                errorLine={error.lineNumber}
-                errorStack={error.stack}
-              />
-            </ThemeProvider>
-          </StyleSheetManager>,
-        ),
-        head: helmetContext.helmet,
-        state: "",
-        UUID,
-      }),
-    );
-};
-
-export default renderSSRComplete;