@beinformed/ui 1.65.13 → 1.65.14

package/src/hooks/useModelCatalog.js

@@ -1,256 +0,0 @@
-// @flow
-import { useSelector, useDispatch } from "react-redux";
-import { useLocation } from "./useRouter";
-
-import { createHref, filterParameters } from "../utils/helpers/createHref";
-
-import ModelCatalogModel from "../models/modelcatalog/ModelCatalogModel";
-import ConceptIndexModel from "../models/concepts/ConceptIndexModel";
-import ConceptDetailModel from "../models/concepts/ConceptDetailModel";
-import { default as BusinessScenarioModel } from "../models/concepts/BusinessScenarioModel";
-import ContentIndexModel from "../models/content/ContentIndexModel";
-import ContentTOCModel from "../models/content/ContentTOCModel";
-import ContentModel from "../models/content/ContentModel";
-
-import { useModularUIBasic } from "./useModularUIBasic";
-import { ContentTypeModel } from "../models";
-
-import { getEntryDate } from "../redux/selectors/modelcatalog";
-import { updateEntryDate } from "../redux/actions/ModelCatalog";
-
-import Href from "../models/href/Href";
-import type { UseModularUIBasicOptions } from "./useModularUIBasic";
-import type { UpdateEntryDateAction } from "../redux";
-export type SearchFilter = {
-  index?: string,
-  label?: string,
-  type?: string | Array<string>,
-  modelCategory?: string | Array<string>,
-  entryDate?: string,
-};
-
-/**
- */
-export const useModelCatalog = (
-  options?: UseModularUIBasicOptions<ModelCatalogModel>,
-): ?ModelCatalogModel =>
-  useModularUIBasic("modelcatalog", "/modelcatalog", {
-    expectedModels: ["ModelCatalog"],
-    targetModel: ModelCatalogModel,
-    ...options,
-  });
-
-/**
- */
-export const useConceptIndex = (
-  href: string | Href,
-  key?: string = "conceptindex",
-  options?: UseModularUIBasicOptions<ConceptIndexModel>,
-): ?ConceptIndexModel => {
-  const { entryDate } = useEntryDate();
-  const url = filterParameters(href, [
-    "index",
-    "label",
-    "modelcategory",
-    "type",
-  ]);
-  url.setParameter("entryDate", entryDate);
-
-  return useModularUIBasic(key, url, {
-    expectedModels: ["ConceptIndex"],
-    targetModel: ConceptIndexModel,
-    ...options,
-  });
-};
-
-/**
- */
-export const useConceptDetail = (
-  concept: string | Href,
-  key?: string = "conceptdetail",
-  options?: UseModularUIBasicOptions<
-    ConceptDetailModel | BusinessScenarioModel,
-  >,
-): ?ConceptDetailModel | ?BusinessScenarioModel => {
-  const { entryDate } = useEntryDate();
-  const location = useLocation();
-
-  const href = createHref("concepts", concept, entryDate, location, []);
-
-  return useModularUIBasic(key, href, {
-    expectedModels: ["ConceptDetail", "BusinessScenario"],
-    ...options,
-  });
-};
-
-/**
- */
-export const useContentIndex = (
-  href: string | Href,
-  key?: string = "contentindex",
-  options?: UseModularUIBasicOptions<ContentIndexModel>,
-): ?ContentIndexModel => {
-  const url = filterParameters(href, ["index", "label", "type"]);
-  return useModularUIBasic(key, url, {
-    expectedModels: ["ContentIndex"],
-    targetModel: ContentIndexModel,
-    ...options,
-  });
-};
-
-/**
- */
-export const useContentTOC = (
-  content: string | Href,
-  key?: string = "contenttoc",
-  options?: UseModularUIBasicOptions<ContentTOCModel>,
-): ?ContentTOCModel => {
-  const { entryDate } = useEntryDate();
-  const location = useLocation();
-
-  const href = createHref("content", content, entryDate, location, [
-    "complete",
-  ]);
-
-  return useModularUIBasic(key, href, {
-    expectedModels: ["ContentTOC"],
-    targetModel: ContentTOCModel,
-    ...options,
-  });
-};
-
-/**
- */
-export const useContent = (
-  content: string | Href,
-  key?: string = "content",
-  options?: UseModularUIBasicOptions<ContentModel>,
-): ?ContentModel | ?ContentTOCModel => {
-  const { entryDate } = useEntryDate();
-  const location = useLocation();
-
-  const href = createHref("content", content, entryDate, location, [
-    "complete",
-  ]);
-
-  return useModularUIBasic(key, href, {
-    expectedModels: ["Content", "ContentTOC"],
-    ...options,
-  });
-};
-
-/**
- */
-export const useCompleteSource = (
-  content: string | Href,
-  key?: string = "content",
-  options?: UseModularUIBasicOptions<ContentModel>,
-): ?ContentModel | ?ContentTOCModel => {
-  const { entryDate } = useEntryDate();
-  const location = useLocation();
-
-  let contentHref = new Href(content);
-  contentHref.removeParameter("complete");
-  contentHref.addParameter("complete", "true");
-
-  const href = createHref("content", contentHref, entryDate, location, [
-    "complete",
-  ]);
-
-  return useModularUIBasic(key, href, {
-    expectedModels: ["Content", "ContentTOC"],
-    ...options,
-  });
-};
-
-/**
- */
-export const useContentType = (
-  contentType: string | Href,
-  key?: string = "contenttypes",
-  options?: UseModularUIBasicOptions<ContentTypeModel>,
-): ?ContentTypeModel => {
-  const href = createHref("contenttypes", contentType, null, null, []);
-  return useModularUIBasic(key, href, {
-    expectedModels: ["ContentType"],
-    targetModel: ContentTypeModel,
-    ...options,
-  });
-};
-
-/**
- */
-const getSearchHref = (uri: string, filters: SearchFilter): string => {
-  const filterString = [];
-
-  for (const key of Object.keys(filters)) {
-    const filterValue = filters[key];
-    if (filterValue) {
-      let value: string = Array.isArray(filterValue)
-        ? filterValue.join(",")
-        : filterValue;
-      if (key === "type") {
-        value = value.replace("#", "%23"); // handles un-encoded #
-      }
-      filterString.push(`${key}=${value}`);
-    }
-  }
-
-  return filterString.length ? `${uri}?${filterString.join("&")}` : uri;
-};
-
-/**
- */
-export const useConceptSearch = (
-  filters: SearchFilter,
-  key?: string = "conceptSearch",
-  options?: UseModularUIBasicOptions<ConceptIndexModel>,
-): ?ConceptIndexModel => {
-  const href = getSearchHref("/concepts", filters);
-  return useConceptIndex(href, key, options);
-};
-
-/**
- */
-export const useContentSearch = (
-  filters: SearchFilter,
-  key?: string = "contentSearch",
-  options?: UseModularUIBasicOptions<ContentIndexModel>,
-): ?ContentIndexModel => {
-  const href = getSearchHref("/content", filters);
-  return useContentIndex(href, key, options);
-};
-
-/**
- * Retrieve and update the entrydate for the modelcatalog
- */
-export const useEntryDate = (): ({
-  entryDate: ISO_DATE,
-  setEntryDate: (entryDate: ISO_DATE) => UpdateEntryDateAction,
-}) => {
-  const dispatch = useDispatch();
-  const entryDate = useSelector(getEntryDate);
-
-  return {
-    entryDate,
-    setEntryDate: (entryDate: ISO_DATE) => dispatch(updateEntryDate(entryDate)),
-  };
-};
-
-/**
- */
-export const useRelatedConcepts = (
-  href: string | Href,
-  key?: string = "relatedconcepts",
-  options?: UseModularUIBasicOptions<ConceptIndexModel>,
-): ?ConceptIndexModel => {
-  const { entryDate } = useEntryDate();
-  const url = filterParameters(href, ["modelcategory"]);
-  url.setParameter("entryDate", entryDate);
-
-  return useModularUIBasic(key, url, {
-    expectedModels: ["ConceptIndex"],
-    targetModel: ConceptIndexModel,
-    ...options,
-  });
-};

package/src/hooks/useModels.js

@@ -1,50 +0,0 @@
-// @flow
-import { createSelector } from "reselect";
-import { useSelector, useDispatch } from "react-redux";
-
-import { reloadModel } from "../redux/_modularui/ModularUIActions";
-import { MODULARUI_STATUS } from "../constants/Constants";
-
-import type { ModularUIModel } from "../models/types";
-import type { ReduxState, ModelEntry } from "../redux";
-
-type ReloadCallback = (model: ModularUIModel) => boolean;
-
-type UseModels = () => {
-  reload: (model: ModularUIModel, options?: any) => void,
-  reloadWithFilter: (callbackFn: ReloadCallback, options?: any) => void,
-};
-
-/**
- * Hook that contains the reload property that can be used to reload a model
- */
-export const useModels: UseModels = () => {
-  const dispatch = useDispatch();
-
-  const selectModularUI = (state: ReduxState) => state.modularui;
-  const selector = createSelector([selectModularUI], (modularui) => {
-    const models = [];
-    const keys = Object.keys(modularui);
-    for (const key of keys) {
-      const model: ModelEntry = modularui[key];
-      if (model?.status === MODULARUI_STATUS.FINISHED) {
-        models.push(model.model);
-      }
-    }
-    return models;
-  });
-
-  const modularuiModels = useSelector(selector);
-
-  return {
-    reload: (model: ModularUIModel, options?: Object) => {
-      dispatch(reloadModel(model, options));
-    },
-    reloadWithFilter: (callbackFn: ReloadCallback, options?: Object) => {
-      const modelsToReload = modularuiModels.filter(callbackFn);
-      for (const modelToReload of modelsToReload) {
-        dispatch(reloadModel(modelToReload, options));
-      }
-    },
-  };
-};

package/src/hooks/useModularUI.js

@@ -1,79 +0,0 @@
-// @flow
-import { useEffect, useRef, useMemo } from "react";
-import { useDispatch, useSelector } from "react-redux";
-import { useLocation } from "react-router";
-
-import { HTTP_METHODS } from "../constants";
-import {
-  loadModularUI,
-  removeModelByKey,
-} from "../redux/_modularui/ModularUIActions";
-
-import useDeepCompareEffect from "./useDeepCompareEffect";
-import { useModularUIKey } from "./useModularUIKey";
-
-import Href from "../models/href/Href";
-import type { RequestModularUIOptions } from "../utils";
-
-/**
- * Core hook to retrieve information for a Be Informed modular ui resource
- */
-export const useModularUI = (
-  modelKey: string,
-  url: string | Href,
-  options: RequestModularUIOptions = {
-    method: HTTP_METHODS.GET,
-    removeOnUnmount: false,
-  },
-): any => {
-  const dispatch = useDispatch();
-  const href = useMemo(() => url?.toString() || "", [url]);
-  const key = useModularUIKey(modelKey, href);
-
-  const modelSelector = useMemo(() => (state) => state.modularui[key], [key]);
-  const model = useSelector(modelSelector);
-
-  if (url instanceof Href) {
-    options.origin = options.origin ?? url.origin;
-    options.contextPath = options.contextPath ?? url.contextPath;
-  }
-
-  const location = useLocation();
-  const redirectLocation = location.state?.redirectLocation;
-  const forceLoad =
-    model == null ||
-    (redirectLocation instanceof Href ? redirectLocation?.equals(href) : false);
-
-  const prevOptions = useRef(options);
-  const prevHref = useRef(href);
-  const prevForceLoad = useRef(forceLoad);
-
-  // dispatch loadModularUI
-  useDeepCompareEffect(() => {
-    // prevent reloads when previous option had the isReload, but the new options not
-    const isOldReload =
-      prevHref.current === href &&
-      prevOptions.current.isReload &&
-      !options.isReload;
-
-    const doForceLoad = forceLoad && !prevForceLoad.current;
-
-    if (href !== "" && (doForceLoad || !isOldReload)) {
-      dispatch(loadModularUI(key, href, options));
-    }
-
-    prevOptions.current = options;
-    prevHref.current = href;
-    prevForceLoad.current = forceLoad;
-  }, [key, href, options, forceLoad]);
-
-  useEffect(() => {
-    if (options.removeOnUnmount) {
-      return () => {
-        dispatch(removeModelByKey(key));
-      };
-    }
-  }, [dispatch, key, options.removeOnUnmount]);
-
-  return model;
-};

package/src/hooks/useModularUIBasic.js

@@ -1,152 +0,0 @@
-// @flow
-import { useLocation } from "react-router";
-import { useSelector } from "react-redux";
-import { useMemo } from "react";
-import { useModularUI } from "./useModularUI";
-
-import { HTTP_METHODS, MODULARUI_STATUS } from "../constants";
-import { useModularUIKey } from "./useModularUIKey";
-
-import type { ModularUIModel, Href } from "../models";
-export type HookOptions = {
-  key?: string,
-  origin?: string,
-  contextPath?: string,
-  removeOnUnmount?: boolean,
-  formdata?: any,
-};
-
-export type UseModularUIBasicOptions<T: ModularUIModel> = {
-  expectedModels?: Array<string>,
-  targetModel?: Class<T> | Array<Class<T>>,
-  forceTargetModel?: boolean,
-  origin?: string,
-  contextPath?: string,
-  cache?: boolean,
-  key?: string,
-  isReload?: boolean,
-  removeOnUnmount?: boolean,
-  formdata?: any,
-};
-
-// Helper to create useModularUI options
-const createUseModularUIOptions = <T: ModularUIModel>(
-  options: UseModularUIBasicOptions<T>,
-  href: string,
-  mustReload: boolean,
-): Object => {
-  const baseOptions = {
-    targetModel: undefined,
-    forceTargetModel: undefined,
-    isReload: false,
-    origin: undefined,
-    contextPath: undefined,
-    cache: false,
-    removeOnUnmount: false,
-    method: HTTP_METHODS.GET,
-    data: undefined,
-  };
-
-  // Handle targetModel and forceTargetModel
-  if (options.targetModel) {
-    baseOptions.targetModel = options.targetModel;
-    baseOptions.forceTargetModel = options.forceTargetModel;
-  }
-
-  // Handle cache option
-  if (options.cache) {
-    baseOptions.cache = options.cache;
-  }
-
-  if (mustReload) {
-    baseOptions.isReload = true;
-  }
-
-  if (options.removeOnUnmount) {
-    baseOptions.removeOnUnmount = true;
-  }
-
-  if (options.formdata != null) {
-    baseOptions.method = HTTP_METHODS.POST;
-    baseOptions.data = options.formdata;
-  }
-
-  // Handle origin and contextPath options
-  baseOptions.origin = options.origin ?? baseOptions.origin;
-  baseOptions.contextPath = options.contextPath ?? baseOptions.contextPath;
-
-  return baseOptions;
-};
-
-// Helper to validate the model against expectedModels
-const validateModel = (model: any, expectedModels: Array<string>) => {
-  if (expectedModels.length > 0) {
-    const isCorrectModel = expectedModels.some(
-      (expectedModel) => model.type === expectedModel,
-    );
-    if (!isCorrectModel) {
-      console.warn(model, "is not of instance", expectedModels);
-    }
-  }
-};
-
-/**
- * useModularUIBasic Hook
- */
-export const useModularUIBasic = <T: ModularUIModel>(
-  defaultKey: string,
-  href: string | Href,
-  options: UseModularUIBasicOptions<T> = {
-    expectedModels: [],
-    targetModel: undefined,
-    forceTargetModel: false,
-    origin: undefined,
-    contextPath: undefined,
-    key: undefined,
-    formdata: undefined,
-  },
-): T | null => {
-  const memoizedHref = useMemo(() => href.toString(), [href]);
-  const key = options.key ?? defaultKey;
-
-  const mustReload = useReload(key, memoizedHref);
-  const modularUIOptions = useMemo(
-    () => createUseModularUIOptions(options, memoizedHref, mustReload),
-    [options, memoizedHref, mustReload],
-  );
-
-  const modularUI = useModularUI(key, href, modularUIOptions);
-  const expectedModels = useMemo(
-    () => options.expectedModels ?? [],
-    [options.expectedModels],
-  );
-
-  return useMemo((): T | null => {
-    if (modularUI?.model) {
-      validateModel(modularUI.model, expectedModels);
-      return modularUI.model;
-    }
-    return null;
-  }, [expectedModels, modularUI]);
-};
-
-/**
- * Check if the model corresponding to a modular ui service should be reloaded
- */
-export const useReload = (modelKey: string, url: string): boolean => {
-  const location = useLocation();
-  const key = useModularUIKey(modelKey, url);
-  const modelEntry = useSelector((state) => state.modularui[key]);
-
-  if (modelEntry) {
-    const reload = location.state?.reload || 0;
-    if (reload > 0) {
-      const isFullyLoaded = modelEntry?.status === MODULARUI_STATUS.FINISHED;
-      const lastModification = modelEntry?.lastModification ?? 0;
-      if (isFullyLoaded && lastModification < reload) {
-        return true;
-      }
-    }
-  }
-  return false;
-};

package/src/hooks/useModularUIKey.js

@@ -1,14 +0,0 @@
-// @flow
-import { useLocale } from "./useI18n";
-import { useMemo } from "react";
-
-/**
- * Generates the key that is used in the modular ui reducer of redux
- */
-export const useModularUIKey = (modelKey: string, url: string): string => {
-  const locale = useLocale();
-  return useMemo(
-    () => `${modelKey}(${url.split("?")[0]})(${locale})`,
-    [modelKey, url, locale],
-  );
-};

package/src/hooks/useModularUIModel.js

@@ -1,86 +0,0 @@
-// @flow
-import ApplicationModel from "../models/application/ApplicationModel";
-import CaseViewModel from "../models/caseview/CaseViewModel";
-import TabModel from "../models/tab/TabModel";
-import GroupingPanelModel from "../models/panels/GroupingPanelModel";
-import DetailModel from "../models/detail/DetailModel";
-import UserProfileModel from "../models/user/UserProfileModel";
-
-import { useModularUIBasic } from "./useModularUIBasic";
-
-import type Href from "../models/href/Href";
-import type { HookOptions } from "./useModularUIBasic";
-
-/**
- * Load application
- */
-export const useApplication = (
-  options?: HookOptions,
-): ApplicationModel | null =>
-  useModularUIBasic("application", "/", {
-    expectedModels: ["Application"],
-    targetModel: ApplicationModel,
-    ...options,
-  });
-
-/**
- * Load a tab by href
- */
-export const useTab = (
-  href: string | Href,
-  options?: HookOptions,
-): TabModel | null =>
-  useModularUIBasic("tab", href, {
-    expectedModels: ["Tab"],
-    targetModel: TabModel,
-    ...options,
-  });
-
-/**
- * Load caseview by href
- */
-export const useCaseView = (
-  href: string | Href,
-  options?: HookOptions,
-): CaseViewModel | null =>
-  useModularUIBasic("caseview", href, {
-    expectedModels: ["CaseView"],
-    targetModel: CaseViewModel,
-    ...options,
-  });
-
-/**
- */
-export const useGroupingPanel = (
-  href: string | Href,
-  options?: HookOptions,
-): GroupingPanelModel | null =>
-  useModularUIBasic("groupingpanel", href, {
-    expectedModels: ["GroupingPanel"],
-    targetModel: GroupingPanelModel,
-    ...options,
-  });
-
-/**
- */
-export const useDetailPanel = (
-  href: string | Href,
-  options?: HookOptions,
-): DetailModel | null =>
-  useModularUIBasic("detailpanel", href, {
-    expectedModels: ["Detail"],
-    targetModel: DetailModel,
-    ...options,
-  });
-
-/**
- */
-export const useUserProfile = (
-  href: string | Href,
-  options?: HookOptions,
-): UserProfileModel | null =>
-  useModularUIBasic("userprofile", href, {
-    expectedModels: ["UserProfile"],
-    targetModel: UserProfileModel,
-    ...options,
-  });

package/src/hooks/useModularUIRequest.js

@@ -1,25 +0,0 @@
-// @flow
-import { createSelector } from "reselect";
-import { useSelector } from "react-redux";
-
-import ModularUIRequest from "../modularui/ModularUIRequest";
-import { getLocale } from "../redux/selectors/i18n";
-
-import type { RequestModularUIOptions } from "../utils";
-import type Href from "../models/href/Href";
-
-const getModularUIRequest = createSelector([getLocale], (localeCode) => {
-  return (href: Href, options?: $Shape<RequestModularUIOptions>) => {
-    const request = new ModularUIRequest(href, options);
-    request.locale = localeCode;
-    return request;
-  };
-});
-
-/**
- * Creates a ModularUIRequest with the locale as available in the redux store
- */
-export const useModularUIRequest = (): ((
-  href: Href,
-  options?: $Shape<RequestModularUIOptions>,
-) => ModularUIRequest) => useSelector(getModularUIRequest);