@ebertjendustries/cswrapper 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2037 @@
+// src/components/CSAlert.tsx
+import { Alert } from "@cloudscape-design/components";
+
+// src/types/CSFormProps.ts
+var FromPropsHelper = class {
+  static getBasicProps = (props) => {
+    const localisationObject = props.localiser.localiseField(props.fieldSpec.getLocalisationKey(), props.localisationVariables, props.alternateNs);
+    const uniqueId = props.fieldSpec.getDataTestId();
+    return { localisationObject, uniqueId };
+  };
+  static usesFormField = (props) => {
+    const localisation = props.localiser.localiseField(props.fieldSpec.getLocalisationKey(), props.localisationVariables, props.alternateNs);
+    return props.formField !== void 0 || localisation?.formField !== void 0;
+  };
+  static getLocalisedErrorText = (props, value, localiseValidity) => {
+    if (props.formField?.errorText !== void 0) {
+      return props.formField?.errorText;
+    }
+    const validityLevel = props.fieldSpec.getValueValidityLevel(value);
+    return localiseValidity(props.fieldSpec, validityLevel);
+  };
+  static sanitizeValueToString = (value) => {
+    if (value === null || value === void 0) {
+      return "";
+    }
+    return value;
+  };
+};
+
+// src/components/CSFormField.tsx
+import { FormField } from "@cloudscape-design/components";
+import { jsx } from "react/jsx-runtime";
+var FORM_FIELD_ID_SUFFIX = "_FORM_FIELD";
+function CSFormField(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const formFieldId = uniqueId + FORM_FIELD_ID_SUFFIX;
+  if (!FromPropsHelper.usesFormField(props)) {
+    return props.children;
+  }
+  return (
+    // IMPORTANT: Order of props determines which one "wins". You can override Elements that are present in the
+    // localisation texts via the additional props. For instance, you can pass in
+    // non-static localisations that require variable values dynamically.
+    /* @__PURE__ */ jsx(FormField, { "data-testid": formFieldId, ...localisationObject?.formField, ...props.formField, children: props.children })
+  );
+}
+
+// src/components/ChildUtils.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ChildUtils = class {
+  static getChildren = (props, localisationObject) => {
+    const childrenRaw = props.children ?? localisationObject?.children;
+    const children = props.childrenWrapper ? props.childrenWrapper(childrenRaw) : childrenRaw;
+    let finalChildren = props.preventOverflow ? /* @__PURE__ */ jsx2("div", { style: {
+      whiteSpace: "nowrap",
+      overflow: "hidden",
+      textOverflow: "ellipsis"
+    }, children }) : children;
+    let formFieldProps = props.formField ?? localisationObject?.formField;
+    if (props.inlineLabel && FromPropsHelper.usesFormField(props)) {
+      finalChildren = /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexWrap: "nowrap" }, children: [
+        /* @__PURE__ */ jsx2("div", { style: {
+          flex: "none",
+          fontWeight: "bold",
+          paddingRight: "5px"
+        }, children: formFieldProps.label + ":" }),
+        finalChildren
+      ] });
+      formFieldProps = { ...formFieldProps, label: void 0 };
+    }
+    return { children: finalChildren, formProps: { ...props, formField: formFieldProps } };
+  };
+};
+
+// src/components/CSAlert.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function CSAlert(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx3(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx3(
+    Alert,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/components/CSBox.tsx
+import { Box } from "@cloudscape-design/components";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function CSBox(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx4(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx4(
+    Box,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/components/CSButton.tsx
+import { Button } from "@cloudscape-design/components";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function CSButton(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx5(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx5(
+    Button,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/components/CSCheckbox.tsx
+import { Checkbox } from "@cloudscape-design/components";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function CSCheckbox(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx6(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx6(
+    Checkbox,
+    {
+      "data-testid": uniqueId,
+      name: uniqueId,
+      controlId: uniqueId,
+      onChange: props.onChange ? props.onChange : ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.checked),
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/components/CSDatePicker.tsx
+import { DatePicker } from "@cloudscape-design/components";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function CSDatePicker(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const sanitizeValue = () => {
+    return new Date(FromPropsHelper.sanitizeValueToString(props.value)).toISOString().split("T")[0];
+  };
+  return /* @__PURE__ */ jsx7(CSFormField, { ...props, children: /* @__PURE__ */ jsx7(
+    DatePicker,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.value),
+      ...props,
+      ...localisationObject,
+      value: sanitizeValue()
+    }
+  ) });
+}
+
+// src/components/CSMultiselect.tsx
+import { Multiselect } from "@cloudscape-design/components";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function CSMultiselect(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  const adaptedOnChange = ({ detail }) => {
+    if (props.enableSelectAll || props.enforceSelection) {
+      if (detail.selectedOptions.length === 0) {
+        props.onChangeValue(props.fieldSpec.key, [props.selectedOptions[0].value]);
+      } else {
+        props.onChangeValue(props.fieldSpec.key, detail.selectedOptions.map((sel) => sel.value));
+      }
+    } else {
+      props.onChangeValue(props.fieldSpec.key, detail.selectedOptions.map((sel) => sel.value));
+    }
+  };
+  const hideTokens = props.hideTokens ?? (props.tokenLimit !== void 0 && props.tokenLimit === 0);
+  return /* @__PURE__ */ jsx8(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx8(
+    Multiselect,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      filteringType: props.filteringType ?? "auto",
+      onChange: adaptedOnChange,
+      enableSelectAll: true,
+      ...props,
+      ...localisationObject,
+      hideTokens,
+      options: props.options
+    }
+  ) });
+}
+
+// src/types/ObjectWithId.ts
+var ObjectWithId = class {
+  id;
+  static idToString = (objectWithId) => {
+    return objectWithId.id ? objectWithId.id.toString() : "<N/A>";
+  };
+  static toObjectWithId = (array, idExtractor) => {
+    return array.map((object) => ({
+      ...object,
+      id: idExtractor(object)
+    }));
+  };
+};
+
+// src/utils/SelectHelper.ts
+var SelectHelper = class _SelectHelper {
+  static singleSelectOptionWithId = (objects, selectedObjectId, toOptionDefinition) => {
+    return this.singleSelectOption(objects, objects.find((importObject) => ObjectWithId.idToString(importObject) === selectedObjectId?.toString()), toOptionDefinition);
+  };
+  static singleSelectOption = (objects, selectedObject, toOptionDefinition) => {
+    const options = objects.map((object) => ({
+      value: ObjectWithId.idToString(object),
+      ...toOptionDefinition(object)
+    }));
+    const selectedOption = selectedObject === void 0 ? null : _SelectHelper.getSelectedOptions(options, [selectedObject.id])[0];
+    return {
+      options,
+      selectedOption
+    };
+  };
+  static singleSelectEnum = (enumFactory, selectedEnum, localiser, exclude) => {
+    const options = enumFactory.values.filter((enumInstance) => exclude === void 0 || !exclude.includes(enumInstance)).map((enumInstance) => {
+      const enumTranslation = localiser.getEnumLocalisation(enumFactory, enumInstance);
+      return {
+        value: enumInstance.toString(),
+        label: enumTranslation.label,
+        description: enumTranslation.description
+      };
+    });
+    const selectedOption = selectedEnum === void 0 ? null : _SelectHelper.getSelectedEnumOptions(options, [selectedEnum.toString()])[0];
+    return {
+      options,
+      selectedOption
+    };
+  };
+  static multiSelectOptions = (objects, selectedObjects, toOptionDefinition) => {
+    const options = objects.map((object) => ({
+      value: ObjectWithId.idToString(object),
+      ...toOptionDefinition(object)
+    }));
+    const selectedOptions = _SelectHelper.getSelectedOptions(options, selectedObjects.map((s) => s.id));
+    return {
+      options,
+      selectedOptions
+    };
+  };
+  static multiSelectEnums = (enumFactory, selectedEnums, localiser) => {
+    const options = enumFactory.values.map((enumInstance) => {
+      const enumTranslation = localiser.getEnumLocalisation(enumFactory, enumInstance);
+      return {
+        value: enumInstance.toString(),
+        label: enumTranslation.label,
+        description: enumTranslation.description
+      };
+    });
+    const selectedOptions = _SelectHelper.getSelectedEnumOptions(options, selectedEnums);
+    return {
+      options,
+      selectedOptions
+    };
+  };
+  static getSelectedOptions = (options, selectedIds) => {
+    const selectedIdsSet = {};
+    selectedIds.forEach((selId) => selId !== void 0 ? selectedIdsSet[selId] = true : null);
+    return options.filter((option) => option.value && selectedIdsSet[parseInt(option.value)]);
+  };
+  static getSelectedEnumOptions = (options, selectedEnums) => {
+    const selectedIdsSet = {};
+    selectedEnums.forEach((selId) => selId !== void 0 ? selectedIdsSet[selId.toString()] = true : null);
+    return options.filter((option) => option.value && selectedIdsSet[option.value]);
+  };
+};
+
+// src/components/CSEnumMultiselect.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function CSEnumMultiselect(props) {
+  return /* @__PURE__ */ jsx9(
+    CSMultiselect,
+    {
+      ...SelectHelper.multiSelectEnums(props.factory, props.selectedEnums, props.localiser),
+      ...props
+    }
+  );
+}
+
+// src/components/CSSegmentedControl.tsx
+import { SegmentedControl } from "@cloudscape-design/components";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function CSSegmentedControl(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx10(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx10(
+    SegmentedControl,
+    {
+      "data-testid": uniqueId,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.selectedId),
+      ...props,
+      ...localisationObject
+    }
+  ) });
+}
+
+// src/components/CSEnumSegmentedControl.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+function CSEnumSegmentedControl(props) {
+  const options = props.factory.values.filter((e) => props.exclude === void 0 || !props.exclude.includes(e)).map((e) => ({
+    text: props.localiser.getEnumLabel(props.factory, e),
+    id: e.toString()
+  }));
+  return /* @__PURE__ */ jsx11(
+    CSSegmentedControl,
+    {
+      selectedId: props.selectedEnum === void 0 ? null : props.selectedEnum.toString(),
+      options,
+      label: props.formField ? props.formField.label : void 0,
+      ...props
+    }
+  );
+}
+
+// src/components/CSSelect.tsx
+import { Select } from "@cloudscape-design/components";
+import { jsx as jsx12 } from "react/jsx-runtime";
+function CSSelect(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx12(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx12(
+    Select,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.selectedOption.value),
+      ...props,
+      ...localisationObject
+    }
+  ) });
+}
+
+// src/components/CSEnumSelect.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function CSEnumSelect(props) {
+  return /* @__PURE__ */ jsx13(
+    CSSelect,
+    {
+      ...SelectHelper.singleSelectEnum(props.factory, props.selectedEnum, props.localiser, props.exclude),
+      ...props
+    }
+  );
+}
+
+// src/components/CSEnumTiles.tsx
+import { Tiles } from "@cloudscape-design/components";
+import { jsx as jsx14 } from "react/jsx-runtime";
+function CSEnumTiles(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const items = props.factory.values.filter((enumInstance) => props.exclude === void 0 || !props.exclude.includes(enumInstance)).map((enumInstance) => {
+    const enumTranslation = props.localiser.getEnumLocalisation(props.factory, enumInstance);
+    return {
+      value: enumInstance.toString(),
+      label: enumTranslation.label,
+      description: enumTranslation.description
+    };
+  });
+  return /* @__PURE__ */ jsx14(
+    Tiles,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      name: uniqueId,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.value),
+      value: props.selectedEnum ? props.selectedEnum.toString() : null,
+      items,
+      ...props,
+      ...localisationObject
+    }
+  );
+}
+
+// src/components/CSLink.tsx
+import { Link } from "@cloudscape-design/components";
+
+// src/utils/BrowserUtils.ts
+var openInNewTab = (link) => {
+  const newWindow = window.open(link, "_blank", "noopener,noreferrer");
+  if (newWindow) newWindow.opener = null;
+};
+var warnWhenTabIsClosed = (isDirty) => {
+  const handleTabClose = (event) => {
+    if (isDirty !== void 0 && !isDirty()) {
+      return void 0;
+    }
+    event.preventDefault();
+    return event.returnValue = "Are you sure you want to exit?";
+  };
+  window.addEventListener("beforeunload", handleTabClose);
+  return () => {
+    window.removeEventListener("beforeunload", handleTabClose);
+  };
+};
+
+// src/components/CSLink.tsx
+import { jsx as jsx15 } from "react/jsx-runtime";
+function CSLink(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx15(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx15(
+    Link,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+function CSExternalLink(props) {
+  return /* @__PURE__ */ jsx15(CSLink, { ...props, external: true, onFollow: (detail) => detail.preventDefault(), children: /* @__PURE__ */ jsx15("span", { onClick: () => openInNewTab(props.link), children: props.children }) });
+}
+
+// src/components/CSHeader.tsx
+import { Header } from "@cloudscape-design/components";
+import { jsx as jsx16 } from "react/jsx-runtime";
+function CSHeader(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx16(
+    Header,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  );
+}
+
+// src/components/CSInput.tsx
+import { Input } from "@cloudscape-design/components";
+import { jsx as jsx17 } from "react/jsx-runtime";
+function CSInput(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  const sanitizedValue = FromPropsHelper.sanitizeValueToString(props.value);
+  const errorText = FromPropsHelper.getLocalisedErrorText(props, sanitizedValue, props.localiser.getFieldValidityLocalisationFunction());
+  return /* @__PURE__ */ jsx17(CSFormField, { ...props, formField: { ...formProps, errorText }, children: /* @__PURE__ */ jsx17(
+    Input,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.value),
+      ...props,
+      ...localisationObject,
+      value: sanitizedValue
+    }
+  ) });
+}
+
+// src/components/CSNumericInput.tsx
+import { Input as Input2 } from "@cloudscape-design/components";
+import { jsx as jsx18 } from "react/jsx-runtime";
+function CSNumericInput(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  const sanitizeValue = () => {
+    if (props.value === void 0 || props.value === null || isNaN(props.value)) {
+      return "";
+    }
+    return FromPropsHelper.sanitizeValueToString(props.value);
+  };
+  const sanitizedValue = sanitizeValue();
+  const errorText = FromPropsHelper.getLocalisedErrorText(props, sanitizedValue, props.localiser.getFieldValidityLocalisationFunction());
+  return /* @__PURE__ */ jsx18(CSFormField, { ...formProps, formField: { ...props.formField, errorText }, children: /* @__PURE__ */ jsx18(
+    Input2,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      onChange: ({ detail }) => {
+        props.onChangeValue(props.fieldSpec.key, props.step && props.step !== "any" && props.step % 1 === 0 ? parseInt(detail.value) : parseFloat(detail.value));
+      },
+      ...props,
+      ...localisationObject,
+      value: sanitizedValue,
+      type: "number",
+      inputMode: "numeric"
+    }
+  ) });
+}
+
+// src/components/CSStatusIndicator.tsx
+import { StatusIndicator } from "@cloudscape-design/components";
+import { jsx as jsx19 } from "react/jsx-runtime";
+function CSStatusIndicator(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx19(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx19(
+    StatusIndicator,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/components/CSTextContent.tsx
+import { TextContent } from "@cloudscape-design/components";
+import { jsx as jsx20 } from "react/jsx-runtime";
+function CSTextContent(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx20(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx20(
+    TextContent,
+    {
+      "data-testid": uniqueId,
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/components/CSTextarea.tsx
+import { Textarea } from "@cloudscape-design/components";
+import { jsx as jsx21 } from "react/jsx-runtime";
+function CSTextarea(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  const sanitizedValue = FromPropsHelper.sanitizeValueToString(props.value);
+  const errorText = FromPropsHelper.getLocalisedErrorText(props, sanitizedValue, props.localiser.getFieldValidityLocalisationFunction());
+  return /* @__PURE__ */ jsx21(CSFormField, { ...props, formField: { ...formProps, errorText }, children: /* @__PURE__ */ jsx21(
+    Textarea,
+    {
+      "data-testid": uniqueId,
+      controlId: uniqueId,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.value),
+      ...props,
+      ...localisationObject,
+      value: sanitizedValue
+    }
+  ) });
+}
+
+// src/components/CSTimeInput.tsx
+import { TimeInput } from "@cloudscape-design/components";
+import { jsx as jsx22 } from "react/jsx-runtime";
+function CSTimeInput(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { formProps } = ChildUtils.getChildren(props, localisationObject);
+  const defaultFormat = "hh:mm";
+  return /* @__PURE__ */ jsx22(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx22(
+    TimeInput,
+    {
+      "data-testid": uniqueId,
+      autoFocus: props.autoFocus,
+      onChange: ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.value),
+      format: props.format ? props.format : defaultFormat,
+      placeholder: props.placeholder ? props.placeholder : defaultFormat,
+      ...props,
+      ...localisationObject
+    }
+  ) });
+}
+
+// src/components/CSToggle.tsx
+import { Toggle } from "@cloudscape-design/components";
+import { jsx as jsx23 } from "react/jsx-runtime";
+function CSToggle(props) {
+  const { localisationObject, uniqueId } = FromPropsHelper.getBasicProps(props);
+  const { children, formProps } = ChildUtils.getChildren(props, localisationObject);
+  return /* @__PURE__ */ jsx23(CSFormField, { ...formProps, children: /* @__PURE__ */ jsx23(
+    Toggle,
+    {
+      "data-testid": uniqueId,
+      name: uniqueId,
+      controlId: uniqueId,
+      onChange: props.onChange ? props.onChange : ({ detail }) => props.onChangeValue(props.fieldSpec.key, detail.checked),
+      ...props,
+      ...localisationObject,
+      children
+    }
+  ) });
+}
+
+// src/views/CSVEnumRatingView.tsx
+import { Rating } from "@smastrom/react-rating";
+import { useEffect, useState } from "react";
+
+// src/utils/EnumFactory.ts
+var EnumFactory = class {
+  constructor(enumName, values) {
+    this.enumName = enumName;
+    this.values = values;
+    if (this.values.length === 0) {
+      throw new Error("Empty localized enum array is not allowed here");
+    }
+  }
+  getEnumIndex(instance) {
+    return this.values.indexOf(instance);
+  }
+};
+
+// src/types/ElementValidityLevel.ts
+var ElementValidityLevel = /* @__PURE__ */ ((ElementValidityLevel2) => {
+  ElementValidityLevel2["VALID"] = "VALID";
+  ElementValidityLevel2["REQUIRED_VALUE_IS_NOT_PRESENT"] = "REQUIRED_VALUE_IS_NOT_PRESENT";
+  ElementValidityLevel2["MAX_LENGTH_EXCEEDED"] = "MAX_LENGTH_EXCEEDED";
+  ElementValidityLevel2["LOWER_BOUND_ONLY_TOO_SMALL"] = "LOWER_BOUND_ONLY_TOO_SMALL";
+  ElementValidityLevel2["UPPER_BOUND_ONLY_TOO_BIG"] = "UPPER_BOUND_ONLY_TOO_BIG";
+  ElementValidityLevel2["BOTH_BOUNDS_OUT_OF_BOUNDS"] = "BOTH_BOUNDS_OUT_OF_BOUNDS";
+  return ElementValidityLevel2;
+})(ElementValidityLevel || {});
+var ELEMENT_VALIDITY_LEVEL_FACTORY = new EnumFactory("ElementValidityLevel", Object.values(ElementValidityLevel));
+
+// src/logging/Log.ts
+var DISABLE_LOGGING = false;
+var Log = class _Log {
+  prefix;
+  debugLogging;
+  constructor(prefix) {
+    this.prefix = prefix ? "[" + prefix + "] " : "";
+    this.debugLogging = true;
+  }
+  static toReadableObjectString(object) {
+    return this.toObjectStr(object, (object2) => JSON.stringify(object2, null, 2));
+  }
+  static toCompactReadableObjectString(object, dependencyCharLimit) {
+    const str = this.toObjectStr(object, (object2) => JSON.stringify(object2));
+    const maxLen = Math.min(str.length, dependencyCharLimit);
+    if (maxLen < str.length) {
+      return str.substring(0, maxLen) + " ( ... continued)";
+    }
+    return str;
+  }
+  static toObjectStr(object, stringify) {
+    if (object === null) {
+      return "null";
+    }
+    if (object === void 0) {
+      return "undefined";
+    }
+    let s = stringify(object);
+    if (s === void 0) {
+      return "function";
+    }
+    return s.replaceAll("\\", "");
+  }
+  /**
+   * log at debugging level
+   */
+  debug(msg, ...supportingDetails) {
+    this.emitLogMessage("debug", msg, supportingDetails);
+  }
+  /**
+   * log at information level
+   */
+  info(msg, ...supportingDetails) {
+    this.emitLogMessage("info", msg, supportingDetails);
+  }
+  /**
+   * log at warning level
+   */
+  warn(msg, ...supportingDetails) {
+    this.emitLogMessage("warn", msg, supportingDetails);
+  }
+  /**
+   * log at error level
+   */
+  error(msg, ...supportingDetails) {
+    this.emitLogMessage("error", msg, supportingDetails);
+  }
+  object(prefixMsg, object) {
+    this.debug(prefixMsg + " " + _Log.toReadableObjectString(object));
+  }
+  effectStart(effectName, msg, dependencies, dependencyCharLimit) {
+    let dependenciesSuffix = "";
+    if (dependencies) {
+      let dependenciesStr = "";
+      for (let i = 0; i < dependencies.length; i++) {
+        const dependency = dependencies[i];
+        dependenciesStr = `${dependenciesStr} Dep[${i}]=<${_Log.toCompactReadableObjectString(dependency, dependencyCharLimit || 60)}>`;
+      }
+      dependenciesSuffix = (msg.length > 0 ? ", " : "") + "DEPS:" + dependenciesStr;
+    }
+    this.effect(`start - ${effectName}`, `${msg}${dependenciesSuffix}`);
+  }
+  effectEnd(effectName) {
+    this.debug(`EFFECT(end - ${effectName})`);
+  }
+  effect(effectName, msg) {
+    this.debug(`EFFECT(${effectName}): ${msg}`);
+  }
+  /**
+   * creates a log message with some detailed information
+   * @param msgType type of message (debug, info, warn, error)
+   * @param msg the message as string
+   * @param supportingDetails details that should be logged
+   */
+  emitLogMessage(msgType, msg, supportingDetails) {
+    if (DISABLE_LOGGING) {
+      return;
+    }
+    const logTS = (/* @__PURE__ */ new Date()).toISOString();
+    if (!this.debugLogging && msgType === "debug") {
+      return;
+    }
+    if (supportingDetails.length > 0) {
+      console[msgType](`${logTS} ${this.prefix}${msg}${supportingDetails}`);
+    } else {
+      console[msgType](`${logTS} ${this.prefix}${msg}`);
+    }
+  }
+};
+
+// src/types/ViewSpec.ts
+var LOGGER = new Log("ViewSpec");
+var ViewElementSpec = class {
+  constructor(key, instanceId) {
+    this.key = key;
+    this.instanceId = instanceId;
+  }
+  parent;
+  ns;
+  dataTestId;
+  localisationKey;
+  keyHierarchy;
+  getDataTestId() {
+    if (this.dataTestId === void 0) {
+      const parentDataTestId = this.parent ? this.parent.getDataTestId() : "";
+      this.dataTestId = this.instanceId ? `${parentDataTestId}${this.key}${this.instanceId}END` : `${parentDataTestId}${this.key}END`;
+    }
+    return this.dataTestId;
+  }
+  getLocalisationKey() {
+    if (this.localisationKey === void 0) {
+      const keys = this.getKeyHierarchy();
+      this.localisationKey = this.ns.createKey(...keys);
+    }
+    return this.localisationKey;
+  }
+  getKeyHierarchy() {
+    if (this.keyHierarchy === void 0) {
+      const parentHierarchy = this.parent ? this.parent.getKeyHierarchy() : [];
+      this.keyHierarchy = [...parentHierarchy, this.key];
+    }
+    return this.keyHierarchy;
+  }
+};
+var FieldSpec = class _FieldSpec extends ViewElementSpec {
+  constructor(key, required, maxLength, minValue, maxValue, customFieldValidator, instanceId) {
+    super(key, instanceId);
+    this.required = required;
+    this.maxLength = maxLength;
+    this.minValue = minValue;
+    this.maxValue = maxValue;
+    this.customFieldValidator = customFieldValidator;
+  }
+  static getTOValidityLevel(transportObject, elements) {
+    if (elements.length === 0) {
+      throw Error("At least one field property must be given");
+    }
+    for (let index = 0; index < elements.length; index++) {
+      const field = elements[index];
+      const fieldValidity = field.getValueValidityLevel(transportObject[field.key]);
+      if (fieldValidity !== "VALID" /* VALID */) {
+        return fieldValidity;
+      }
+    }
+    return "VALID" /* VALID */;
+  }
+  static isTOValid(transportObject, Elements) {
+    return this.getTOValidityLevel(transportObject, Elements) === "VALID" /* VALID */;
+  }
+  static debugLogElementValidityArray(elements, Elements) {
+    for (let index = 0; index < elements.length; index++) {
+      const element = elements[index];
+      _FieldSpec.debugLogElementValidity(element, "idx=" + index.toString(), Elements);
+    }
+  }
+  static debugLogElementValidity(element, elementId, Elements) {
+    for (const field of Elements) {
+      const fieldValidity = _FieldSpec.getTOValidityLevel(element, [field]);
+      LOGGER.info(`Field validity level, element id = <${elementId}>, field name = <${field.getDataTestId()}>, validity level = <${fieldValidity.toString()}>.`);
+    }
+  }
+  getValueValidityLevel(value) {
+    if (this.customFieldValidator) {
+      return this.customFieldValidator(this, value);
+    }
+    const isString = value !== void 0 && value !== null && (typeof value === "string" || value instanceof String);
+    const isNumber = value !== void 0 && value !== null && typeof value === "number";
+    if (this.required && (value === void 0 || value === null || isString && value.trim().length === 0 || isNumber && isNaN(value))) {
+      return "REQUIRED_VALUE_IS_NOT_PRESENT" /* REQUIRED_VALUE_IS_NOT_PRESENT */;
+    }
+    if (isString && this.maxLength !== void 0 && value.length > this.getMaxLength()) {
+      return "MAX_LENGTH_EXCEEDED" /* MAX_LENGTH_EXCEEDED */;
+    }
+    if (isNumber) {
+      if (this.minValue !== void 0 && this.maxValue === void 0 && this.minValue > value) {
+        return "LOWER_BOUND_ONLY_TOO_SMALL" /* LOWER_BOUND_ONLY_TOO_SMALL */;
+      }
+      if (this.maxValue !== void 0 && this.minValue === void 0 && this.maxValue < value) {
+        return "UPPER_BOUND_ONLY_TOO_BIG" /* UPPER_BOUND_ONLY_TOO_BIG */;
+      }
+      if (this.minValue !== void 0 && this.maxValue !== void 0 && (this.minValue > value || this.maxValue < value)) {
+        return "BOTH_BOUNDS_OUT_OF_BOUNDS" /* BOTH_BOUNDS_OUT_OF_BOUNDS */;
+      }
+    }
+    return "VALID" /* VALID */;
+  }
+  getMaxLength() {
+    return this.maxLength ? this.maxLength : Number.MAX_SAFE_INTEGER;
+  }
+};
+var ViewSpec = class _ViewSpec extends ViewElementSpec {
+  constructor(key, ns, instanceId, customViewValidator) {
+    super(key, instanceId);
+    this.ns = ns;
+    if (!customViewValidator) {
+      this.viewValidator = () => "VALID" /* VALID */;
+    } else {
+      this.viewValidator = customViewValidator;
+    }
+  }
+  elements;
+  viewValidator;
+  static create(key, ns, elementDefinition, instanceId, parent, customViewValidator) {
+    const viewSpec = new _ViewSpec(key, ns, instanceId, customViewValidator);
+    viewSpec.parent = parent;
+    viewSpec.elements = elementDefinition(viewSpec);
+    return viewSpec;
+  }
+  addField(fieldSpec) {
+    fieldSpec.parent = this;
+    fieldSpec.ns = this.ns;
+    return fieldSpec;
+  }
+  addFieldFromProps(fieldProps, customFieldValidator, instanceId) {
+    const fieldSpec = new FieldSpec(fieldProps.key, fieldProps.required, fieldProps.maxLength, fieldProps.minValue, fieldProps.maxValue, customFieldValidator, instanceId);
+    fieldSpec.parent = this;
+    fieldSpec.ns = this.ns;
+    return fieldSpec;
+  }
+  addView(viewSpecProvider, key, instanceId) {
+    const viewSpec = viewSpecProvider(this, key, instanceId);
+    viewSpec.ns = this.ns;
+    return viewSpec;
+  }
+  getAllElements() {
+    return Object.values(this.elements);
+  }
+  getValueValidityLevel(value) {
+    return this.viewValidator(this, value);
+  }
+};
+
+// src/views/CSVEnumRatingView.tsx
+import { jsx as jsx24, jsxs as jsxs2 } from "react/jsx-runtime";
+var CSV_ENUM_RATING_VIEW_SPEC = (parent, key, instanceId) => ViewSpec.create(key, parent.ns, (spec) => ({
+  rating: spec.addField(new FieldSpec("rating")),
+  boxRatingName: spec.addField(new FieldSpec("boxRatingName"))
+}), instanceId, parent);
+function getEnumRatingValues(factory, toOrderNumber) {
+  return toOrderNumber ? factory.values.sort((e1, e2) => toOrderNumber(e1) - toOrderNumber(e2)) : factory.values;
+}
+function getEnumRatingLabel(enumInstance, instanceId) {
+  return `${instanceId}_${enumInstance.toString()}`;
+}
+function CSVEnumRatingView(props) {
+  const spec = props.viewSpec;
+  const { elements } = spec;
+  const [hoveredValue, setHoveredValue] = useState(props.selectedEnum);
+  const valuesInOrder = getEnumRatingValues(props.factory, props.toOrderNumber);
+  const onHover = (hoveredIndex) => {
+    if (hoveredIndex === 0) {
+      setHoveredValue(props.selectedEnum);
+    } else {
+      setHoveredValue(valuesInOrder[hoveredIndex]);
+    }
+  };
+  const itemCount = Math.max(1, Math.min(valuesInOrder.length - 1, 10));
+  useEffect(() => {
+    setHoveredValue(props.selectedEnum);
+  }, [props.selectedEnum]);
+  return /* @__PURE__ */ jsxs2(CSFormField, { fieldSpec: elements.rating, localiser: props.localiser, children: [
+    /* @__PURE__ */ jsx24(
+      Rating,
+      {
+        "data-testid": elements.rating.getDataTestId(),
+        isDisabled: props.disabled,
+        style: { maxWidth: 100 },
+        items: itemCount,
+        value: !props.disabled ? valuesInOrder.indexOf(props.selectedEnum) : 0,
+        onHoverChange: onHover,
+        onChange: (selectedIndex) => props.onChangeValue(spec.key, valuesInOrder[selectedIndex]),
+        invisibleItemLabels: valuesInOrder.slice(1).map((e) => getEnumRatingLabel(e, spec.instanceId))
+      }
+    ),
+    /* @__PURE__ */ jsx24("div", { style: { textAlign: "left", paddingLeft: "5px" }, children: /* @__PURE__ */ jsx24(
+      CSBox,
+      {
+        fieldSpec: elements.boxRatingName,
+        localiser: props.localiser,
+        variant: !props.disabled ? "div" : "small",
+        children: hoveredValue !== void 0 ? props.localiser.getEnumLabel(props.factory, hoveredValue) : void 0
+      }
+    ) })
+  ] });
+}
+
+// src/views/CSVNoItemsView.tsx
+import { Box as Box2, SpaceBetween } from "@cloudscape-design/components";
+import { jsx as jsx25, jsxs as jsxs3 } from "react/jsx-runtime";
+var CSV_NO_ITEMS_VIEW_SPEC = (ns) => ViewSpec.create("CSVNoItemsView", ns, (spec) => ({
+  boxHeading: spec.addField(new FieldSpec("boxHeading")),
+  boxBody: spec.addField(new FieldSpec("boxBody"))
+}));
+function CSVNoItemsView(props) {
+  const spec = props.viewSpec;
+  const { elements } = spec;
+  return /* @__PURE__ */ jsx25("div", { "data-testid": spec.getDataTestId(), children: /* @__PURE__ */ jsx25(Box2, { textAlign: "center", color: "inherit", children: /* @__PURE__ */ jsxs3(SpaceBetween, { size: "xxs", direction: "vertical", children: [
+    /* @__PURE__ */ jsx25(
+      CSBox,
+      {
+        fieldSpec: elements.boxHeading,
+        localiser: props.localiser,
+        alternateNs: spec.ns,
+        variant: "strong",
+        color: "inherit",
+        children: props.headingText
+      }
+    ),
+    /* @__PURE__ */ jsx25(
+      CSBox,
+      {
+        fieldSpec: elements.boxBody,
+        localiser: props.localiser,
+        alternateNs: spec.ns,
+        localisationVariables: { itemType: props.localiser.getEnumLabel(props.factory, props.itemType) },
+        variant: "p",
+        color: "inherit",
+        children: props.bodyText
+      }
+    ),
+    props.bodyNode
+  ] }) }) });
+}
+
+// src/views/CSVPriceInputView.tsx
+import { Grid } from "@cloudscape-design/components";
+
+// src/utils/PriceUtils.ts
+var LOGGER2 = new Log("PriceUtils");
+var PriceUtils = class {
+  static getFormattedPrice = (locale, price) => {
+    if (isNaN(price.priceInCents)) {
+      return "-";
+    }
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: price.currency.toString()
+    }).format(price.priceInCents / 100);
+  };
+  static sumPrices = (prices, defaultCurrency) => {
+    if (prices.length === 0) {
+      return { priceInCents: 0, currency: defaultCurrency };
+    }
+    const currencySet = this.getCurrenciesFromPrices(prices);
+    if (currencySet.size > 1) {
+      LOGGER2.warn("Different currencies found in price array to be summed - the final price is incorrect!", currencySet);
+    }
+    const summedPrice = prices.map((pr) => pr.priceInCents).reduce((sum, current) => sum + current);
+    return { priceInCents: summedPrice, currency: prices[0].currency };
+  };
+  static getCurrenciesFromPrices = (prices) => {
+    const currencySet = /* @__PURE__ */ new Set();
+    prices.forEach((pr) => currencySet.add(pr.currency));
+    return currencySet;
+  };
+  static getPriceValidityLevel = (spec, value) => {
+    const centsValidity = spec.elements.inputPrice.getValueValidityLevel(value.priceInCents);
+    if (centsValidity !== "VALID" /* VALID */) {
+      return centsValidity;
+    }
+    return spec.elements.selectCurrency.getValueValidityLevel(value.currency);
+  };
+  static parseFormattedPrice = (locale, formattedPrice, currency) => {
+    const thousandSeparator = Intl.NumberFormat(locale).format(11111).replace(/\p{Number}/gu, "");
+    const decimalSeparator = Intl.NumberFormat(locale).format(1.1).replace(/\p{Number}/gu, "");
+    const sanitizedPrice = formattedPrice.replace(new RegExp("\\" + thousandSeparator, "g"), "").replace(new RegExp("\\" + decimalSeparator), ".").replace(new RegExp("[^0-9.]", "g"), "").trim();
+    const parsedPriceCents = Math.round(100 * parseFloat(sanitizedPrice));
+    return { priceInCents: parsedPriceCents, currency };
+  };
+  static parseFormattedPriceWithCurrency = (locale, formattedPrice, currencySymbolMapping) => {
+    const thousandSeparator = Intl.NumberFormat(locale).format(11111).replace(/\p{Number}/gu, "");
+    const decimalSeparator = Intl.NumberFormat(locale).format(1.1).replace(/\p{Number}/gu, "");
+    const sanitizedPrice = formattedPrice.replace(new RegExp("\\" + thousandSeparator, "g"), "").replace(new RegExp("\\" + decimalSeparator), ".").replace(new RegExp("[^0-9.]", "g"), "").trim();
+    const parsedPriceCents = Math.round(100 * parseFloat(sanitizedPrice));
+    const supportedCurrencies = Object.keys(currencySymbolMapping);
+    const currencySymbolsFound = supportedCurrencies.filter((symbol) => formattedPrice.includes(symbol));
+    if (currencySymbolsFound.length > 1) {
+      throw new Error(`Multiple currency symbols found in formatter price string ${formattedPrice}, here are the supported currencies: ${supportedCurrencies}`);
+    }
+    return {
+      priceInCents: parsedPriceCents,
+      currency: currencySymbolMapping[currencySymbolsFound[0]]
+    };
+  };
+};
+
+// src/views/CSVPriceInputView.tsx
+import { jsx as jsx26, jsxs as jsxs4 } from "react/jsx-runtime";
+var CSV_PRICE_INPUT_VIEW_SPEC = (parent, key) => ViewSpec.create(key, parent.ns, (spec) => ({
+  inputPrice: spec.addField(new FieldSpec("inputPrice", true, void 0, 0)),
+  selectCurrency: spec.addField(new FieldSpec("currency", true)),
+  boxPriceDisplay: spec.addField(new FieldSpec("boxPriceDisplay"))
+}), key, parent, PriceUtils.getPriceValidityLevel);
+function CSVPriceInputView(props) {
+  const spec = props.viewSpec;
+  const { elements } = spec;
+  const priceInCents = props.value ? props.value.priceInCents : 0;
+  const currency = props.value ? props.value.currency : props.defaultCurrency;
+  return /* @__PURE__ */ jsxs4(
+    Grid,
+    {
+      gridDefinition: [{ colspan: 4 }, { colspan: { default: 4, xxs: 3 } }, { colspan: { default: 4, xxs: 5 } }],
+      disableGutters: true,
+      children: [
+        /* @__PURE__ */ jsx26(
+          CSNumericInput,
+          {
+            fieldSpec: elements.inputPrice,
+            value: priceInCents / 100,
+            step: 0.01,
+            disabled: props.disabled,
+            localiser: props.localiser,
+            onChangeValue: (propertyName, changedValue) => props.onChange(props.viewSpec.key, {
+              priceInCents: parseFloat(changedValue) * 100,
+              currency
+            })
+          }
+        ),
+        /* @__PURE__ */ jsx26("div", { style: { paddingLeft: "8px" }, children: /* @__PURE__ */ jsx26(
+          CSEnumSelect,
+          {
+            fieldSpec: elements.selectCurrency,
+            localiser: props.localiser,
+            factory: props.currencyFactory,
+            selectedEnum: currency,
+            disabled: props.disabled,
+            onChangeValue: (propertyName, changedValue) => props.onChange(props.viewSpec.key, {
+              priceInCents,
+              currency: changedValue
+            }),
+            expandToViewport: props.expandToViewport
+          }
+        ) }),
+        /* @__PURE__ */ jsx26("div", { style: { paddingTop: "30px", paddingLeft: "8px" }, children: /* @__PURE__ */ jsx26(
+          CSBox,
+          {
+            fieldSpec: elements.boxPriceDisplay,
+            localiser: props.localiser,
+            fontSize: "heading-s",
+            fontWeight: "heavy",
+            variant: "awsui-key-label",
+            children: PriceUtils.getFormattedPrice(props.localiser.language(), { priceInCents, currency })
+          }
+        ) })
+      ]
+    }
+  );
+}
+
+// src/views/CSVSearchFilterView.tsx
+import { SpaceBetween as SpaceBetween2 } from "@cloudscape-design/components";
+import { jsx as jsx27, jsxs as jsxs5 } from "react/jsx-runtime";
+var CSV_SEARCH_FILTER_VIEW_SPEC = (parent, key) => ViewSpec.create(key, parent.ns, (spec) => ({
+  inputSearch: spec.addField(new FieldSpec("inputSearch")),
+  buttonSearch: spec.addField(new FieldSpec("buttonSearch"))
+}), void 0, parent);
+function CSVSearchFilterView(props) {
+  const spec = props.viewSpec;
+  const { elements } = spec;
+  return /* @__PURE__ */ jsxs5(SpaceBetween2, { size: "s", direction: "horizontal", children: [
+    /* @__PURE__ */ jsx27("div", { style: { minWidth: "320px" }, children: props.inputSearch === void 0 || typeof props.inputSearch === "string" ? /* @__PURE__ */ jsx27(
+      CSInput,
+      {
+        fieldSpec: elements.inputSearch,
+        localiser: props.localiser,
+        autoFocus: true,
+        placeholder: props.inputSearch,
+        onChangeValue: props.onChangeValue,
+        value: props.searchString,
+        type: "search"
+      }
+    ) : props.inputSearch }),
+    props.buttonSearch === void 0 || typeof props.buttonSearch === "string" ? /* @__PURE__ */ jsx27(
+      CSButton,
+      {
+        fieldSpec: elements.buttonSearch,
+        localiser: props.localiser,
+        variant: "primary",
+        iconName: "search",
+        onClick: props.onConfirmSearch,
+        formAction: "submit",
+        loading: props.loading,
+        disabled: props.searchDisabled,
+        children: props.buttonSearch
+      }
+    ) : props.buttonSearch
+  ] });
+}
+
+// src/views/CSVTextPromptModalView.tsx
+import { Box as Box3, Modal, SpaceBetween as SpaceBetween3 } from "@cloudscape-design/components";
+import { Fragment, jsx as jsx28, jsxs as jsxs6 } from "react/jsx-runtime";
+var CSV_TEXT_PROMPT_MODAL_VIEW_SPEC = (parent, key) => ViewSpec.create(key, parent.ns, (spec) => ({
+  headerHeading: spec.addField(new FieldSpec("headerHeading")),
+  boxBodyText: spec.addField(new FieldSpec("boxBodyText")),
+  buttonPrimary: spec.addField(new FieldSpec("buttonPrimary")),
+  buttonSecondary: spec.addField(new FieldSpec("buttonSecondary"))
+}), void 0, parent);
+function CSVTextPromptModalView(props) {
+  const spec = props.viewSpec;
+  const { elements } = spec;
+  const secondaryAction = props.onSecondaryAction ? props.buttonSecondary === void 0 || typeof props.buttonSecondary === "string" ? /* @__PURE__ */ jsx28(
+    CSButton,
+    {
+      fieldSpec: elements.buttonSecondary,
+      localiser: props.localiser,
+      variant: "normal",
+      onClick: props.onSecondaryAction,
+      children: props.buttonSecondary
+    }
+  ) : props.buttonSecondary : /* @__PURE__ */ jsx28(Fragment, {});
+  return /* @__PURE__ */ jsx28(
+    Modal,
+    {
+      "data-testid": props.viewSpec.getDataTestId(),
+      onDismiss: props.onDismiss,
+      visible: props.visible,
+      header: props.headerHeading === void 0 || typeof props.headerHeading === "string" ? /* @__PURE__ */ jsx28(
+        CSHeader,
+        {
+          fieldSpec: elements.headerHeading,
+          localiser: props.localiser,
+          children: props.headerHeading
+        }
+      ) : props.headerHeading,
+      footer: /* @__PURE__ */ jsx28(Box3, { float: "right", children: /* @__PURE__ */ jsxs6(SpaceBetween3, { direction: "horizontal", size: "l", children: [
+        props.buttonPrimary === void 0 || typeof props.buttonPrimary === "string" ? /* @__PURE__ */ jsx28(
+          CSButton,
+          {
+            fieldSpec: elements.buttonPrimary,
+            localiser: props.localiser,
+            variant: "primary",
+            onClick: props.onPrimaryAction,
+            children: props.buttonPrimary
+          }
+        ) : props.buttonPrimary,
+        secondaryAction
+      ] }) }),
+      children: props.boxBodyText === void 0 || typeof props.boxBodyText === "string" ? /* @__PURE__ */ jsx28(CSBox, { fieldSpec: elements.boxBodyText, localiser: props.localiser, children: props.boxBodyText }) : props.boxBodyText
+    }
+  );
+}
+
+// src/hooks/ControllerState.ts
+var ControllerState = /* @__PURE__ */ ((ControllerState2) => {
+  ControllerState2[ControllerState2["UNMOUNTED"] = 0] = "UNMOUNTED";
+  ControllerState2[ControllerState2["INITIALIZING"] = 1] = "INITIALIZING";
+  ControllerState2[ControllerState2["NORMAL"] = 2] = "NORMAL";
+  ControllerState2[ControllerState2["FATAL_ERROR"] = 3] = "FATAL_ERROR";
+  return ControllerState2;
+})(ControllerState || {});
+
+// src/utils/DateUtils.ts
+var DateUtils = class _DateUtils {
+  static dateAsString(date) {
+    const dd = String(date.getDate()).padStart(2, "0");
+    const mm = String(date.getMonth() + 1).padStart(2, "0");
+    const yyyy = date.getFullYear();
+    return yyyy + "-" + mm + "-" + dd;
+  }
+  static dateAsDateTimeString(date, language) {
+    return date.toLocaleDateString(language) + " " + date.toLocaleTimeString(language);
+  }
+  static nextSundayAt(hour, minute, second) {
+    const today = /* @__PURE__ */ new Date();
+    const addDays = 7 - today.getDay();
+    const nextSunday = new Date(today.getTime() + addDays * 24 * 60 * 60 * 1e3);
+    nextSunday.setHours(hour, minute, second, 0);
+    return nextSunday;
+  }
+  static getCurrentUserTimezone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+  static dateTimeAsUTCISO8601String(date) {
+    const hh = String(date.getHours()).padStart(2, "0");
+    const MM = String(date.getMinutes()).padStart(2, "0");
+    const ss = String(date.getSeconds()).padStart(2, "0");
+    return _DateUtils.dateAsString(date) + "T" + hh + ":" + MM + ":" + ss + "Z";
+  }
+  static currentDateTimeAsUTCISO8601String() {
+    const now = /* @__PURE__ */ new Date();
+    return _DateUtils.dateTimeAsUTCISO8601String(now);
+  }
+  static currentDateAsISO8601String() {
+    const now = /* @__PURE__ */ new Date();
+    return _DateUtils.dateAsString(now);
+  }
+  static toFormattedLocalizedDate(locale, inputInUTCISO8601, timezone) {
+    if (inputInUTCISO8601 === void 0 || inputInUTCISO8601 === null) {
+      return "";
+    }
+    return new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false,
+      timeZone: timezone
+    }).format(new Date(inputInUTCISO8601));
+  }
+};
+
+// src/types/FieldProperties.ts
+var FieldProperties = class {
+  constructor(key, required, maxLength, minValue, maxValue) {
+    this.key = key;
+    this.required = required;
+    this.maxLength = maxLength;
+    this.minValue = minValue;
+    this.maxValue = maxValue;
+  }
+};
+
+// src/utils/FixedWidth.tsx
+import { jsx as jsx29 } from "react/jsx-runtime";
+function FixedWidth(props) {
+  return /* @__PURE__ */ jsx29("div", { style: { minWidth: props.minWidth, maxWidth: props.maxWidth }, children: props.children });
+}
+
+// src/utils/LocalStorageService.ts
+var ITEM_SEP = ",";
+var LocalStorageService = class {
+  static getItemStringArrayWithDefault(key, defaultValue) {
+    const result = this.safeGetItem(key);
+    if (result === null) {
+      return defaultValue;
+    }
+    return result.split(ITEM_SEP);
+  }
+  static getItemEnumArrayWithDefault(enumClass, key, defaultValue) {
+    const enumConstantsAsStrings = this.getItemStringArrayWithDefault(key, defaultValue.map((s) => s.toString()));
+    const keys = Object.keys(enumClass);
+    const values = Object.values(enumClass);
+    const dict = {};
+    for (let index = 0; index < keys.length; index++) {
+      dict[values[index]] = keys[index];
+    }
+    return enumConstantsAsStrings.map((val) => dict[val]);
+  }
+  static setItemEnumArray(key, value) {
+    this.setItemStringArray(key, value.map((e) => e.toString()));
+  }
+  static setItemStringArray(key, value) {
+    this.safeSetItem(key, value.join(","));
+  }
+  static getItemWithDefault(key, defaultValue) {
+    const result = this.safeGetItem(key);
+    if (result === null) {
+      return defaultValue;
+    }
+    return result;
+  }
+  static setItem(key, value) {
+    return this.safeSetItem(key, value);
+  }
+  static clear() {
+    window.localStorage.clear();
+  }
+  static setObject(key, value) {
+    return this.safeSetItem(key, JSON.stringify(value));
+  }
+  static getObjectWithDefault(key, defaultValue) {
+    const result = this.safeGetItem(key);
+    if (result === null) {
+      return defaultValue;
+    }
+    return JSON.parse(result);
+  }
+  static safeGetItem(key) {
+    try {
+      return localStorage.getItem(key);
+    } catch (error) {
+      console.log(`WARNING: could not get item with key ${key} from local storage due to exception: ${error}`);
+      return null;
+    }
+  }
+  static safeSetItem(key, value) {
+    try {
+      return localStorage.setItem(key, value);
+    } catch (error) {
+      console.log(`WARNING: could not set item with key ${key} and value ${value} in local storage due to exception: ${error}`);
+      return null;
+    }
+  }
+};
+
+// src/localisation/LocalisationNamespace.ts
+var LocalisationNamespace = class {
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   *
+   * @param parts The parts. Call this with comma-separated args, e.g. createKey(arg1, arg2, arg3) or with array using following syntax:
+   *   createKey(...[arg1, arg2, arg3]). DO NOT call it directly with an array!
+   *   This is WRONG: createKey([arg1, arg2, arg3]). It will treat the array as single arg and call toString() on it.
+   */
+  createKey(...parts) {
+    return this.name + "." + parts.join(".");
+  }
+};
+var NSK_CONTENT = "content";
+
+// src/localisation/Localiser.ts
+var Localiser = class {
+  constructor(translate, ns) {
+    this.translate = translate;
+    this.ns = ns;
+  }
+  getEnumLabel(factory, instance) {
+    return this.getEnumLocalisation(factory, instance).label;
+  }
+  getAllEnumLabels(factory) {
+    return factory.values.map((instance) => this.getEnumLabel(factory, instance));
+  }
+};
+
+// src/types/messaging/MessageSeverity.ts
+var MessageSeverity = /* @__PURE__ */ ((MessageSeverity2) => {
+  MessageSeverity2["INFO"] = "INFO";
+  MessageSeverity2["WARN"] = "WARN";
+  MessageSeverity2["ERR"] = "ERR";
+  MessageSeverity2["SUCCESS"] = "SUCCESS";
+  return MessageSeverity2;
+})(MessageSeverity || {});
+var MESSAGE_SEVERITY_FACTORY = new EnumFactory("MessageSeverity", Object.values(MessageSeverity));
+
+// src/types/messaging/MessageCTO.ts
+var MessageCTO = class {
+  static TIMESTAMP_PROPS = new FieldProperties("timestamp", true);
+  static DETAIL_MESSAGE_PROPS = new FieldProperties("detailMessage", true);
+  static CORRELATION_ID_PROPS = new FieldProperties("correlationId", true);
+  static OPERATION_PROPS = new FieldProperties("operation", true);
+  code;
+  timestamp;
+  detailMessage;
+  correlationId;
+  operation;
+};
+
+// src/types/messaging/MessageCodeTO.ts
+var MessageCodeTO = class {
+  static CONTROLLER_ID_PROPS = new FieldProperties("componentId", true);
+  static HTTP_STATUS_CODE_PROPS = new FieldProperties("httpStatusCode", true);
+  static LOCAL_CODE_PROPS = new FieldProperties("localCode", true);
+  static MESSAGE_SEVERITY_PROPS = new FieldProperties("messageSeverity", true);
+  static UNIQUE_CODE_PROPS = new FieldProperties("uniqueCode", true);
+  componentId;
+  httpStatusCode;
+  localCode;
+  messageSeverity;
+  uniqueCode;
+};
+
+// src/types/messaging/MessageService.ts
+var TECHNICAL_CONTROLLER_ID = "T";
+var NO_HTTP_CODE = 0;
+var MessageService = class _MessageService {
+  static getResponseTOWithMessagesFromUnknownResponse(json, op, status) {
+    const response = json !== void 0 && json !== null && json.hasOwnProperty("messages") ? json : _MessageService.createGenericErrorMessageTO(status, op);
+    response.messages.forEach((m) => m.operation = op);
+    return response;
+  }
+  static getSuccessContentWithMessagesCTO(json, op) {
+    let result = { content: void 0, messages: [] };
+    if (json.hasOwnProperty("content")) {
+      result.content = json.content;
+    }
+    if (json.hasOwnProperty("messages")) {
+      result.messages = json.messages;
+    }
+    result.messages.forEach((m) => m.operation = op);
+    return result;
+  }
+  static createContentWithSuccessMessage = (operation, message) => {
+    return this.createContentWithMessage(this.createMessageTO(
+      TECHNICAL_CONTROLLER_ID,
+      NO_HTTP_CODE.toString(),
+      0,
+      message,
+      operation,
+      "SUCCESS" /* SUCCESS */
+    ));
+  };
+  static createContentWithoutMessages = (content) => {
+    return {
+      messages: [],
+      content
+    };
+  };
+  static createContentWithInfoMessage = (operation, message) => {
+    return this.createContentWithMessage(this.createMessageTO(
+      TECHNICAL_CONTROLLER_ID,
+      NO_HTTP_CODE.toString(),
+      0,
+      message,
+      operation,
+      "INFO" /* INFO */
+    ));
+  };
+  static createGenericErrorMessageTO = (httpStatusCode, operation) => {
+    if (this.isAPIClientCallError(httpStatusCode)) {
+      return this.createContentWithMessage(this.createMessageTO(TECHNICAL_CONTROLLER_ID, "998", httpStatusCode, "Generic API call client error", operation));
+    } else if (this.isBackendError(httpStatusCode)) {
+      return this.createContentWithMessage(this.createMessageTO(TECHNICAL_CONTROLLER_ID, "999", httpStatusCode, "Generic backend error", operation));
+    } else {
+      throw new Error("Calling this methods with any http status code outside 400-599 is not allowed.");
+    }
+  };
+  static createCriticalErrorFrontendProcessingMessageTO = (operation, message) => {
+    return this.createMessageTO(TECHNICAL_CONTROLLER_ID, "997", -1, message, operation);
+  };
+  static isAPIClientCallError = (httpStatusCode) => {
+    return httpStatusCode >= 400 && httpStatusCode <= 499;
+  };
+  static isBackendError = (httpStatusCode) => {
+    return httpStatusCode >= 500 && httpStatusCode <= 599;
+  };
+  static createContentWithMessage(message) {
+    return {
+      messages: [message],
+      content: void 0
+    };
+  }
+  static createMessageTO = (componentId, localCode, httpStatusCode, detailMessage, operation, severity) => {
+    const message = new MessageCTO();
+    message.code = new MessageCodeTO();
+    message.code.httpStatusCode = httpStatusCode;
+    message.code.componentId = componentId;
+    message.code.localCode = localCode;
+    message.code.uniqueCode = componentId + localCode;
+    message.code.messageSeverity = severity ? severity : "ERR" /* ERR */;
+    message.operation = operation;
+    message.correlationId = "N/A";
+    message.timestamp = DateUtils.currentDateTimeAsUTCISO8601String();
+    message.detailMessage = detailMessage;
+    return message;
+  };
+};
+
+// src/utils/QueryParamHelper.ts
+var QUERY_START = "?";
+var QUERY_SEP = "&";
+var QueryParamHelper = class {
+  static appendQueryParam(query, key, value) {
+    let result = query;
+    if (!query.includes(QUERY_START)) {
+      result = result + QUERY_START;
+    }
+    if (result[result.length - 1] !== QUERY_START) {
+      result = result + QUERY_SEP;
+    }
+    return result + encodeURIComponent(key) + "=" + encodeURIComponent(value);
+  }
+  static getQueryParams(queryString) {
+    const returnedParams = {};
+    if (queryString === void 0 || queryString.length === 0 || !queryString.startsWith(QUERY_START)) {
+      return returnedParams;
+    }
+    queryString = queryString.substring(1);
+    const params = queryString.split(QUERY_SEP);
+    if (params.length === 0 || params.length === 1 && params[0] === "") {
+      return returnedParams;
+    }
+    params.forEach((param) => {
+      const paramRegex = /^(?<key>.*?)=(?<value>.*?)$/;
+      const matchArray = param.match(paramRegex);
+      if (matchArray !== null && matchArray.groups) {
+        const key = decodeURIComponent(matchArray.groups["key"]);
+        returnedParams[key] = decodeURIComponent(matchArray.groups["value"]);
+      }
+    });
+    return returnedParams;
+  }
+};
+
+// src/utils/RestClient.ts
+var REST_CLIENT_LOGGER = new Log("RestClient");
+function logStart(logMsg, url) {
+  REST_CLIENT_LOGGER.debug("START " + logMsg + " using URL <" + url + "> ...");
+}
+function logDone(logMsg, url) {
+  REST_CLIENT_LOGGER.debug("DONE " + logMsg + " using URL <" + url + "> .");
+}
+function logError(logMsg, url) {
+  REST_CLIENT_LOGGER.debug("ERROR: ", logMsg, ", using URL <" + url + "> .");
+}
+function createRestClient() {
+  return new RestClient("");
+}
+var RestClient = class {
+  // Base URL. May be empty.
+  baseUrl = "";
+  prepareFetchConfig(method, payload, header = {}) {
+    let headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...header
+    };
+    let config;
+    if (payload) {
+      config = {
+        method,
+        headers,
+        body: JSON.stringify(payload)
+      };
+    } else {
+      config = {
+        method,
+        headers
+      };
+    }
+    return config;
+  }
+  /**
+   * Creates a new REST client.
+   * @param baseUrl base URL, so client can be called with relative URLs.
+   */
+  constructor(baseUrl) {
+    if (baseUrl != null) {
+      this.baseUrl = baseUrl;
+    }
+  }
+  /**
+   * Make a GET request on the specified endpoint
+   *
+   * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+   * @param {string} operation the operation name for logging.
+   * @param {string} headers the HTTP headers to pass.
+   */
+  get(endpoint, operation, headers) {
+    return this.callApi("get", endpoint, null, operation, headers);
+  }
+  /**
+   * Make a PUT request on the specified endpoint
+   *
+   * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+   * @param {object} payload the request payload as object.
+   * @param {string} operation the operation name for logging.
+   */
+  put(endpoint, payload, operation) {
+    return this.callApi("put", endpoint, payload, operation);
+  }
+  /**
+   * Make a POST request on the specified endpoint
+   *
+   * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+   * @param {object} payload the request payload as object.
+   * @param {string} operation the operation name for logging.
+   */
+  post(endpoint, payload, operation) {
+    return this.callApi("post", endpoint, payload, operation);
+  }
+  /**
+   * Make a DELETE request on the specified endpoint
+   *
+   * @param {string} endpoint the endpoint relative to the baseUrl with a preceeding slash. e.g. '/users'.
+   * @param {object} payload the request payload as object.
+   * @param {string} operation the operation name for logging.
+   */
+  del(endpoint, payload, operation) {
+    return this.callApi("delete", endpoint, payload, operation);
+  }
+  callApi(method, endpoint = "", payload = null, operation, header) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const config = this.prepareFetchConfig(method, payload, header);
+    const op = operation ? operation : "Unknown operation";
+    logStart(op, url);
+    REST_CLIENT_LOGGER.debug("Calling API - " + method + "," + url);
+    REST_CLIENT_LOGGER.object("Payload", payload);
+    return new Promise((resolve, reject) => {
+      fetch(url, config).then((response) => {
+        const contentType = response.headers.get("content-type");
+        if (contentType && contentType.indexOf("application/json") !== -1) {
+          return response.json().then((json) => ({
+            status: response.status,
+            json
+          }));
+        } else {
+          return response.text().then((text) => ({
+            status: response.status,
+            json: {}
+          }));
+        }
+      }).then((result) => {
+        const { status, json } = result;
+        if (status >= 400) {
+          logError(op, url);
+          REST_CLIENT_LOGGER.error("Api call failed with response code " + status + ", response body=" + Log.toReadableObjectString(json));
+          const responseWithMessages = MessageService.getResponseTOWithMessagesFromUnknownResponse(json, op, status);
+          return reject(responseWithMessages);
+        } else {
+          logDone(op, url);
+          REST_CLIENT_LOGGER.debug("Api call successful " + status + ", response body=" + Log.toReadableObjectString(json));
+          if (json === null || json === void 0) {
+            const msg = "Invalid response body - must never be null or undefined";
+            REST_CLIENT_LOGGER.error(msg);
+            const responseWithMessages2 = {
+              content: void 0,
+              messages: [MessageService.createCriticalErrorFrontendProcessingMessageTO(op, msg)]
+            };
+            return reject(responseWithMessages2);
+          }
+          const responseWithMessages = MessageService.getSuccessContentWithMessagesCTO(json, op);
+          return resolve(responseWithMessages);
+        }
+      }).catch((error) => {
+        const msg = "Api call failed with unknown/network error during promise processing " + error;
+        REST_CLIENT_LOGGER.error(msg);
+        const responseWithMessages = {
+          content: void 0,
+          messages: [MessageService.createCriticalErrorFrontendProcessingMessageTO(op, msg)]
+        };
+        return reject(responseWithMessages);
+      });
+    });
+  }
+};
+
+// src/hooks/useControllerDisplayState.ts
+import { useCallback, useState as useState2 } from "react";
+var RunFunctionResult = class {
+  constructor(success, messages, result, resultHistory) {
+    this.success = success;
+    this.messages = messages;
+    this.result = result;
+    this.resultHistory = resultHistory;
+  }
+};
+var fatalRunErrorFunction = (reason) => {
+  throw new Error(`Fatal error - could not handle run failure - reason: ${reason}`);
+};
+function useControllerDisplayState(initialDisplayMode, messages, logger) {
+  const [state, setState] = useState2(0 /* UNMOUNTED */);
+  const [loadingIndication, setLoadingIndication] = useState2({});
+  const [modified, setModified] = useState2(false);
+  const [displayMode, setDisplayMode] = useState2(initialDisplayMode);
+  const [modalState, setModalState] = useState2({
+    show: (modalId, confirmFunction) => showModal(modalId, true, confirmFunction),
+    hide: (modalId) => showModal(modalId, false)
+  });
+  const { addMessages } = messages;
+  const isLoading = useCallback((service) => {
+    return loadingIndication.hasOwnProperty(service.name) && loadingIndication[service.name] === true;
+  }, [loadingIndication]);
+  const load = useCallback((service) => {
+    setLoadingIndication((oldIndication) => ({ ...oldIndication, [service.name]: true }));
+  }, []);
+  const doneLoading = useCallback((service) => {
+    setLoadingIndication((oldIndication) => {
+      return { ...oldIndication, [service.name]: false };
+    });
+  }, []);
+  const enterDisplayMode = useCallback((mode) => {
+    setDisplayMode((previousMode) => {
+      if (mode !== displayMode) {
+        logger.info("Entering display mode: ", mode);
+        return mode;
+      }
+      return previousMode;
+    });
+  }, [displayMode, logger]);
+  const showModal = useCallback((modalId, show, confirmFunction) => {
+    if (show) {
+      setModalState((originalModalState) => {
+        if (originalModalState.modalId !== void 0) {
+          throw Error("Cannot show multiple modals at the same time");
+        }
+        return { ...originalModalState, modalId, confirmFunction };
+      });
+    } else {
+      setModalState((originalModalState) => {
+        if (originalModalState.modalId === void 0 || originalModalState.modalId !== modalId) {
+          throw Error("Cannot hide modal that isn't currently shown");
+        }
+        return { ...originalModalState, modalId: void 0, confirmFunction: void 0 };
+      });
+    }
+  }, []);
+  const run = useCallback(function(service, execute, failureIsFatal, resultHistory) {
+    load(service);
+    return execute().then((result) => {
+      addMessages(result);
+      return Promise.resolve(new RunFunctionResult(
+        true,
+        result.messages,
+        result.content,
+        resultHistory
+      ));
+    }).catch((error) => {
+      if (failureIsFatal) {
+        setState(3 /* FATAL_ERROR */);
+      }
+      addMessages(error);
+      return Promise.resolve(new RunFunctionResult(false, error.messages, void 0, resultHistory));
+    }).finally(() => doneLoading(service));
+  }, [addMessages, doneLoading, load]);
+  return {
+    state,
+    setState,
+    setDirty: useCallback(setModified, [setModified]),
+    isDirty: () => modified,
+    isLoading,
+    displayMode,
+    enterDisplayMode,
+    modalState,
+    run
+  };
+}
+
+// src/utils/MiscUtils.ts
+var indexRangeArray = (length) => {
+  return Array.from({ length }, (x, i) => i);
+};
+function filterArrayByIndices(items, indices) {
+  return items.filter((value, index) => indices.includes(index));
+}
+function sortArrayByIndices(items, indices) {
+  return items.filter((value, index) => indices.includes(index)).sort((left, right) => indices.indexOf(items.indexOf(left)) - indices.indexOf(items.indexOf(right)));
+}
+var sleep = (delaySeconds) => new Promise((resolve) => setTimeout(resolve, delaySeconds));
+
+// src/types/messaging/ContentWithMessagesCTO.ts
+function isContentWithMessages(object) {
+  return object.hasOwnProperty("messages");
+}
+
+// src/hooks/useTOChangeHandler.ts
+import { useCallback as useCallback2 } from "react";
+var ArrayStateHandler = class {
+  static updateFieldsOfArrayElement(elementToUpdate, currentArrayContent, properties, onChangedArrayElement) {
+    const newArrayValue = [...currentArrayContent];
+    const affectedElementIndex = newArrayValue.indexOf(elementToUpdate);
+    newArrayValue[affectedElementIndex] = { ...elementToUpdate, ...properties };
+    if (onChangedArrayElement) {
+      onChangedArrayElement([newArrayValue[affectedElementIndex]], newArrayValue);
+    }
+    return newArrayValue;
+  }
+  static removeArrayElements(elementsToRemove, currentArrayContent, onRemovedArrayElement) {
+    const newArrayValue = [...currentArrayContent.filter((element) => elementsToRemove.indexOf(element) === -1)];
+    if (onRemovedArrayElement) {
+      onRemovedArrayElement(elementsToRemove, newArrayValue);
+    }
+    return newArrayValue;
+  }
+  static addArrayElements(elementsToAdd, currentArrayContent, onAddedArrayElements) {
+    const newArrayValue = [...currentArrayContent, ...elementsToAdd];
+    if (onAddedArrayElements) {
+      onAddedArrayElements(elementsToAdd, newArrayValue);
+    }
+    return newArrayValue;
+  }
+};
+function useTOChangeHandler(logger, toName, setTOState, notifications, setDirty) {
+  const onPropertyChangeMulti = useCallback2((properties, automaticChange) => {
+    logger.debug(`Changing state of the ${toName} Elements ${Object.keys(properties)} for affected element, using change object:`, JSON.stringify(properties));
+    setTOState((previousValue) => {
+      const newValue = { ...previousValue, ...properties };
+      if (notifications && notifications.onChange) {
+        for (const propertyName of Object.keys(properties)) {
+          const changedValue = properties[propertyName];
+          notifications.onChange(newValue, propertyName, changedValue);
+        }
+      }
+      if (previousValue !== void 0 && setDirty !== void 0 && !automaticChange) {
+        setDirty(true);
+      }
+      return newValue;
+    });
+  }, [logger, notifications, setDirty, setTOState, toName]);
+  const onPropertyChange = useCallback2((propertyName, changedValue, automaticChange) => {
+    onPropertyChangeMulti({ [propertyName]: changedValue }, automaticChange);
+  }, [onPropertyChangeMulti]);
+  return { onPropertyChange, onPropertyChangeMulti };
+}
+var singleChangeHandlerToMulti = (onPropertyChangeMulti) => {
+  return (propertyName, changedValue) => onPropertyChangeMulti({ [propertyName]: changedValue });
+};
+function useTOArrayChangeHandler(logger, toName, setArrayState, handlers, setDirty) {
+  const onChangeElement = useCallback2((element, properties) => {
+    if (element !== void 0) {
+      logger.debug(`Changing state of the ${toName} Elements ${Object.keys(properties)} for affected element, using change object:`, JSON.stringify(properties));
+      setArrayState((previousValue) => ArrayStateHandler.updateFieldsOfArrayElement(
+        element,
+        previousValue,
+        properties,
+        handlers.onChange
+      ));
+      if (setDirty !== void 0) {
+        setDirty(true);
+      }
+    }
+  }, [logger, toName, setArrayState, setDirty, handlers.onChange]);
+  const onRemoveElements = useCallback2((removedElements) => {
+    if (removedElements.length > 0) {
+      logger.debug(`Removing ${removedElements.length} elements from array`);
+      setArrayState((previousValue) => ArrayStateHandler.removeArrayElements(
+        removedElements,
+        previousValue,
+        handlers.onRemove
+      ));
+      if (setDirty !== void 0) {
+        setDirty(true);
+      }
+    }
+  }, [logger, setArrayState, setDirty, handlers.onRemove]);
+  const onAddElements = useCallback2((newElements) => {
+    if (newElements.length === 0) {
+      logger.debug(`Adding no new elements to array`);
+    } else {
+      logger.debug(`Adding ${newElements.length} elements to array`);
+      setArrayState((previousValue) => ArrayStateHandler.addArrayElements(
+        newElements,
+        previousValue,
+        handlers.onAdd
+      ));
+      if (setDirty !== void 0) {
+        setDirty(true);
+      }
+    }
+  }, [logger, setArrayState, setDirty, handlers.onAdd]);
+  return { onChangeElement, onRemoveElements, onAddElements };
+}
+
+// src/hooks/useAWSUIRef.ts
+import { useCallback as useCallback3, useRef } from "react";
+function useAWSUIRef() {
+  const customRef = useRef(null);
+  const isValidRef = () => {
+    return customRef !== void 0 && customRef !== null && customRef.current !== void 0 && customRef.current !== null;
+  };
+  const focus = useCallback3(() => {
+    if (isValidRef() && customRef.current.focus) {
+      customRef.current.focus();
+    }
+  }, [customRef]);
+  const scrollToView = useCallback3(() => {
+    if (isValidRef() && customRef.current.scrollIntoView) {
+      customRef.current.scrollIntoView(true);
+    }
+  }, [customRef]);
+  const scrollToViewRef = useCallback3((element) => {
+    if (element !== void 0 && element !== null && element.scrollIntoView) {
+      element.scrollIntoView({ block: "nearest", behavior: "smooth" });
+    }
+  }, []);
+  return {
+    customRef,
+    focus,
+    scrollToView,
+    scrollToViewRef
+  };
+}
+
+// src/hooks/useHotkeys.ts
+import { useCallback as useCallback4, useEffect as useEffect2, useLayoutEffect, useRef as useRef2 } from "react";
+var useHotkey = (key, shift, ctrl, alt, callback, node = null) => {
+  const callbackRef = useRef2(callback);
+  useLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
+  const handleKeyPress = useCallback4(
+    (event) => {
+      if (event.key === key && (!shift || event.shiftKey) && (!ctrl || event.ctrlKey) && (!alt || event.altKey)) {
+        callbackRef.current(event);
+      }
+    },
+    [alt, ctrl, key, shift]
+  );
+  useEffect2(() => {
+    const targetNode = node ?? document;
+    targetNode && targetNode.addEventListener("keydown", handleKeyPress);
+    return () => targetNode && targetNode.removeEventListener("keydown", handleKeyPress);
+  }, [handleKeyPress, node]);
+};
+
+// src/hooks/useMessages.ts
+import { useCallback as useCallback5, useState as useState3 } from "react";
+function useMessages(LOGGER3) {
+  const [messages, setMessages] = useState3([]);
+  const onDismissMessage = useCallback5((message) => {
+    const newMessages = messages.filter((existingMsg) => message !== existingMsg);
+    setMessages(newMessages);
+  }, [messages]);
+  const onToggleMessageDetail = useCallback5((message) => {
+    const idx = messages.indexOf(message);
+    const newMessages = [...messages];
+    newMessages[idx].showDetails = !newMessages[idx].showDetails;
+    setMessages(newMessages);
+  }, [messages]);
+  const addMessages = useCallback5((newMessages) => {
+    if (!newMessages.hasOwnProperty("messages")) {
+      LOGGER3.error("Given response data structure does not contain messages - probably another runtime error occurred: ", newMessages);
+      if (newMessages.hasOwnProperty("stack")) {
+        LOGGER3.error("Stack trace: ", newMessages.stack);
+      }
+    } else {
+      const addedMessages = newMessages.messages.map((msg) => {
+        return { ...msg, showDetails: false };
+      });
+      addedMessages.forEach((msg) => LOGGER3.info(`New message = <${msg.detailMessage}`));
+      setMessages((oldMessages) => [...oldMessages, ...addedMessages]);
+    }
+  }, [LOGGER3]);
+  const clearMessages = useCallback5(() => {
+    setMessages([]);
+  }, []);
+  return {
+    messages,
+    addMessages,
+    onDismissMessage,
+    onToggleMessageDetail,
+    clearMessages
+  };
+}
+export {
+  CSAlert,
+  CSBox,
+  CSButton,
+  CSCheckbox,
+  CSDatePicker,
+  CSEnumMultiselect,
+  CSEnumSegmentedControl,
+  CSEnumSelect,
+  CSEnumTiles,
+  CSExternalLink,
+  CSFormField,
+  CSHeader,
+  CSInput,
+  CSLink,
+  CSMultiselect,
+  CSNumericInput,
+  CSSegmentedControl,
+  CSSelect,
+  CSStatusIndicator,
+  CSTextContent,
+  CSTextarea,
+  CSTimeInput,
+  CSToggle,
+  CSVEnumRatingView,
+  CSVNoItemsView,
+  CSVPriceInputView,
+  CSVSearchFilterView,
+  CSVTextPromptModalView,
+  CSV_ENUM_RATING_VIEW_SPEC,
+  CSV_NO_ITEMS_VIEW_SPEC,
+  CSV_PRICE_INPUT_VIEW_SPEC,
+  CSV_SEARCH_FILTER_VIEW_SPEC,
+  CSV_TEXT_PROMPT_MODAL_VIEW_SPEC,
+  ChildUtils,
+  ControllerState,
+  DateUtils,
+  ELEMENT_VALIDITY_LEVEL_FACTORY,
+  ElementValidityLevel,
+  EnumFactory,
+  FORM_FIELD_ID_SUFFIX,
+  FieldProperties,
+  FieldSpec,
+  FixedWidth,
+  FromPropsHelper,
+  LocalStorageService,
+  LocalisationNamespace,
+  Localiser,
+  Log,
+  MESSAGE_SEVERITY_FACTORY,
+  MessageCTO,
+  MessageCodeTO,
+  MessageService,
+  MessageSeverity,
+  NO_HTTP_CODE,
+  NSK_CONTENT,
+  ObjectWithId,
+  PriceUtils,
+  QUERY_SEP,
+  QUERY_START,
+  QueryParamHelper,
+  REST_CLIENT_LOGGER,
+  RestClient,
+  RunFunctionResult,
+  SelectHelper,
+  TECHNICAL_CONTROLLER_ID,
+  ViewSpec,
+  createRestClient,
+  fatalRunErrorFunction,
+  filterArrayByIndices,
+  getEnumRatingLabel,
+  getEnumRatingValues,
+  indexRangeArray,
+  isContentWithMessages,
+  openInNewTab,
+  singleChangeHandlerToMulti,
+  sleep,
+  sortArrayByIndices,
+  useAWSUIRef,
+  useControllerDisplayState,
+  useHotkey,
+  useMessages,
+  useTOArrayChangeHandler,
+  useTOChangeHandler,
+  warnWhenTabIsClosed
+};