@beinformed/ui 1.62.8 → 1.63.0

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

@@ -0,0 +1,265 @@
+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%3Dhello%20world%26filter%3Dtest",
+      );
+    });
+
+    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%3DJohn%20Doe%20%26%20email%3Djohn%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%3D123",
+      );
+
+      // Verify the returned object is an instance of the mock Href
+      expect(hrefInstance.url).toBe("/products?id%3D123");
+    });
+
+    it("should handle complex URLs and pass them to Href", () => {
+      const request = createMockRequest({
+        pathInfo: "/search/results",
+        queryString: "q=javascript%20xss&param=value",
+      });
+      const hrefInstance = getFullRequestHref(request);
+      expect(require("../../models/href/Href")).toHaveBeenCalledWith(
+        "/search/results?q%3Djavascript%2520xss%26param%3Dvalue",
+      );
+      expect(hrefInstance.url).toBe(
+        "/search/results?q%3Djavascript%2520xss%26param%3Dvalue",
+      );
+    });
+  });
+
+  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/requestInformation.js

@@ -6,11 +6,16 @@ import type Locales from "../i18n/Locales";
 /**
  */
 export const getFullRequestUrl = (request: HttpServletRequestJava): string => {
-  const pathInfo = request.getPathInfo() || "/";
-  const queryString = request.getQueryString();
+  let pathInfo = request.getPathInfo() || "/";
+  let queryString = request.getQueryString();
+
+  pathInfo = pathInfo
+    .split("/")
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
 
   if (queryString) {
-    return `${pathInfo}?${queryString}`;
+    return `${pathInfo}?${encodeURIComponent(queryString)}`;
   }
 
   return pathInfo;

package/esm/builder/index.d.ts

@@ -1 +0,0 @@
-export * from "./mergeLayoutHintConfigurations";

package/esm/builder/mergeLayoutHintConfigurations.d.ts

@@ -1 +0,0 @@
-export function mergeLayoutHintConfigurations(srcFolder: string, outputFolder: string): Promise<void>;

package/esm/constants/Constants.d.ts

@@ -1,158 +0,0 @@
-/**
- * path to content service
- */
-export const CONTENT_PATH: "/content";
-/**
- * Upload Path
- */
-export const UPLOAD_PATH: "/uploadFile";
-/**
- * Captcha Path
- */
-export const CAPTCHA_PATH: "/captchaServices";
-/**
- * Path to change avatar page / component
- */
-export const CHANGEAVATAR_PATH: "/change-avatar";
-/**
- * Path to change password page / component
- */
-export const CHANGEPASSWORD_PATH: "/change-password";
-/**
- * Path to user profile page / component
- */
-export const USERPROFILE_PATH: "/user";
-/**
- * Path to resources in the Be Informed repository
- */
-export const RESOURCE_PATH: "/resource";
-/**
- * Separator for parameters of a list, makes it possible to render multiple lists on a page in a non-js environment
- */
-export const PARAMETER_SEPARATOR: "~";
-/**
- * Timeversion filter name
- */
-export const TIMEVERSION_FILTER_NAME: "entryDate";
-/**
- * Parameter name for the viewtype toggle
- */
-export const DEFAULT_UI_PARAMETERS: Array<string>;
-/**
- */
-export const ISO_DATE_FORMAT: "yyyy-MM-dd";
-/**
- */
-export const ISO_DATETIME_FORMAT: "yyyy-MM-dd'T'HH:mm:ss";
-/**
- */
-export const ISO_TIME_FORMAT: "HH:mm:ss";
-/**
- */
-export const ISO_TIMESTAMP_FORMAT: "yyyy-MM-dd'T'HH:mm:ss.SSS";
-/**
- * Offset format is appended to iso datetime and timestamp when isIncludeTimeOffsetInDateTimes = true
- */
-export const DATETIME_OFFSET_FORMAT: "xxx";
-/**
- * week starts on monday by default
- */
-export const DEFAULT_WEEK_STARTS_ON: 1;
-/**
- * first week indicated by the 1st of january
- */
-export const DEFAULT_FIRST_WEEK_CONTAINS_DATE: 1;
-/**
- * Key codes
- * @type {{SPACE: number, PAGE_DOWN: number, TAB: number, ARROW_RIGHT: number, ARROW_DOWN: number, ENTER: number, ARROW_UP: number, ARROW_LEFT: number, PAGE_UP: number, ESCAPE: number}}
- */
-export const KEYCODES: {
-    SPACE: number;
-    PAGE_DOWN: number;
-    TAB: number;
-    ARROW_RIGHT: number;
-    ARROW_DOWN: number;
-    ENTER: number;
-    ARROW_UP: number;
-    ARROW_LEFT: number;
-    PAGE_UP: number;
-    ESCAPE: number;
-};
-/**
- * @type {boolean}
- */
-export const IS_SYNC: boolean;
-/**
- * @type {boolean}
- */
-export const IS_SERVER: boolean;
-/**
- * @type {boolean}
- */
-export const IS_GRAALJS: boolean;
-/**
- * @type {{SUCCESS: string, ERROR: string, INFO: string, WARNING: string}}
- */
-export const NOTIFICATION_TYPES: {
-    SUCCESS: string;
-    ERROR: string;
-    INFO: string;
-    WARNING: string;
-};
-/**
- * SUPPORTED HTTP METHODS
- * @type {{POST: string, GET: string}}
- */
-export const HTTP_METHODS: {
-    POST: string;
-    GET: string;
-};
-/**
- * POSSIBLE MODULARUI STATUSSES
- * @type {{LOADING: string, ERROR: string, FINISHED: string}}
- */
-export const MODULARUI_STATUS: {
-    LOADING: string;
-    ERROR: string;
-    FINISHED: string;
-};
-/**
- * POSSIBLE AUTOSAVE STATUSSES
- * @type {{START: string, FINISHED: string}}
- */
-export const AUTOSAVE_STATUS: {
-    START: string;
-    FINISHED: string;
-};
-/**
- * DEBOUNCE INPUT TIMEOUT
- */
-export const INPUT_DEBOUNCE_TIMEOUT: 100;
-/**
- * DEBOUNCE VALIDATION TIMEOUT
- */
-export const VALIDATE_DEBOUNCE_TIMEOUT: 500;
-export namespace ATTRIBUTE_WIDTH {
-    let EXTRA_SMALL: string;
-    let SMALL: string;
-    let MEDIUM: string;
-    let LARGE: string;
-    let EXTRA_LARGE: string;
-}
-export const ALL_CONTENT_IN_DATA_SETTING: "hasAllContentInData";
-export const INCLUDE_TIME_OFFSET: "isIncludeTimeOffsetInDateTimes";
-export namespace INTERNAL_LOGIN_TYPE {
-    let JAAS: string;
-    let PAC4J_FORM: string;
-    let PAC4J_BASIC: string;
-}
-export const LOGIN_TYPE: "security.clients";
-export const LOGIN_PATH_SETTING: "FormClient.login_url";
-export const LOGIN_USERNAME_SETTING: "FormClient.username_field_name";
-export const LOGIN_PASSWORD_SETTING: "FormClient.password_field_name";
-export const LOGOUT_PATH_SETTING: "FormClient.logout_url";
-export namespace DEFAULT_AUTHENTICATION_TYPE {
-    let name: string;
-    let authentication: string;
-    let isPrimary: boolean;
-}