fastapi-rtk 1.0.29 → 1.0.31

package/dist/.external/esm/@jsonforms_core@3.7.0/@jsonforms/core/lib/jsonforms-core.esm.mjs

@@ -17,11 +17,12 @@ import setFp from "../../../../../../.bundled/jsonforms/esm/_virtual/set.mjs";
 import unsetFp from "../../../../../../.bundled/jsonforms/esm/_virtual/unset.mjs";
 import isFunction from "../../../../../../.bundled/jsonforms/esm/_virtual/isFunction.mjs";
 import maxBy from "../../../../../../.bundled/jsonforms/esm/_virtual/maxBy.mjs";
-import "../../../../../../.bundled/jsonforms/esm/_virtual/remove.mjs";
-import "../../../../../../.bundled/jsonforms/esm/_virtual/endsWith.mjs";
-import "../../../../../../.bundled/jsonforms/esm/_virtual/last.mjs";
+import remove from "../../../../../../.bundled/jsonforms/esm/_virtual/remove.mjs";
+import endsWith from "../../../../../../.bundled/jsonforms/esm/_virtual/endsWith.mjs";
+import last from "../../../../../../.bundled/jsonforms/esm/_virtual/last.mjs";
 import reduce from "../../../../../../.bundled/jsonforms/esm/_virtual/reduce.mjs";
 import toPairs from "../../../../../../.bundled/jsonforms/esm/_virtual/toPairs.mjs";
+import isUndefined from "../../../../../../.bundled/jsonforms/esm/_virtual/isUndefined.mjs";
 const ADDITIONAL_PROPERTIES = "additionalProperties";
 const REQUIRED_PROPERTIES = "required";
 const distinct = (properties, discriminator) => {
@@ -151,6 +152,7 @@ const createId = (proposedId) => {
   return newID;
 };
 const removeId = (id) => usedIds.delete(id);
+const clearAllIds = () => usedIds.clear();
 const compose = (path1, path2) => {
   let p1 = path1;
   if (!isEmpty(path1) && !isEmpty(path2) && !path2.startsWith("[")) {
@@ -172,6 +174,9 @@ const toDataPathSegments = (schemaPath) => {
   const startIndex = startFromRoot ? 2 : 1;
   return range(startIndex, decodedSegments.length, 2).map((idx) => decodedSegments[idx]);
 };
+const toDataPath = (schemaPath) => {
+  return toDataPathSegments(schemaPath).join(".");
+};
 const encode = (segment) => segment == null ? void 0 : segment.replace(/~/g, "~0").replace(/\//g, "~1");
 const decode = (pointerSegment) => pointerSegment == null ? void 0 : pointerSegment.replace(/~1/g, "/").replace(/~0/, "~");
 const getPropPath = (path) => {
@@ -188,6 +193,9 @@ const deriveLabel = (controlElement, schemaElement) => {
   }
   return "";
 };
+const createCleanLabel = (label) => {
+  return startCase(label.replace("_", " "));
+};
 const createLabelDescriptionFrom = (withLabel, schema) => {
   const labelProperty = withLabel.label;
   if (typeof labelProperty === "boolean") {
@@ -207,6 +215,12 @@ const labelDescription = (text, show) => ({
   text,
   show
 });
+const isObjectSchema$1 = (schema) => {
+  return schema.properties !== void 0;
+};
+const isArraySchema = (schema) => {
+  return schema.type === "array" && schema.items !== void 0;
+};
 const resolveData = (instance, dataPath) => {
   if (isEmpty(dataPath)) {
     return instance;
@@ -219,6 +233,29 @@ const resolveData = (instance, dataPath) => {
     return curInstance[decodedSegment];
   }, instance);
 };
+const findAllRefs = (schema, result = {}, resolveTuples = false) => {
+  if (isObjectSchema$1(schema)) {
+    Object.keys(schema.properties).forEach((key) => findAllRefs(schema.properties[key], result));
+  }
+  if (isArraySchema(schema)) {
+    if (Array.isArray(schema.items)) {
+      if (resolveTuples) {
+        const items = schema.items;
+        items.forEach((child) => findAllRefs(child, result));
+      }
+    } else {
+      findAllRefs(schema.items, result);
+    }
+  }
+  if (Array.isArray(schema.anyOf)) {
+    const anyOf = schema.anyOf;
+    anyOf.forEach((child) => findAllRefs(child, result));
+  }
+  if (schema.$ref !== void 0) {
+    result[schema.$ref] = schema;
+  }
+  return result;
+};
 const invalidSegment = (pathSegment) => pathSegment === "#" || pathSegment === void 0 || pathSegment === "";
 const resolveSchema = (schema, schemaPath, rootSchema) => {
   const result = doResolveSchema(schema, schemaPath, {
@@ -312,6 +349,152 @@ const resolveSingleStep = (schema, pathSegments) => {
     resolvedSegment: segment
   };
 };
+const Draft4 = {
+  id: "http://json-schema.org/draft-04/schema#",
+  $schema: "http://json-schema.org/draft-04/schema#",
+  description: "Core schema meta-schema",
+  definitions: {
+    schemaArray: {
+      type: "array",
+      minItems: 1,
+      items: { $ref: "#" }
+    },
+    positiveInteger: {
+      type: "integer",
+      minimum: 0
+    },
+    positiveIntegerDefault0: {
+      allOf: [{ $ref: "#/definitions/positiveInteger" }, { default: 0 }]
+    },
+    simpleTypes: {
+      enum: [
+        "array",
+        "boolean",
+        "integer",
+        "null",
+        "number",
+        "object",
+        "string"
+      ]
+    },
+    stringArray: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 1,
+      uniqueItems: true
+    }
+  },
+  type: "object",
+  properties: {
+    id: {
+      type: "string",
+      format: "uri"
+    },
+    $schema: {
+      type: "string",
+      format: "uri"
+    },
+    title: {
+      type: "string"
+    },
+    description: {
+      type: "string"
+    },
+    default: {},
+    multipleOf: {
+      type: "number",
+      minimum: 0,
+      exclusiveMinimum: true
+    },
+    maximum: {
+      type: "number"
+    },
+    exclusiveMaximum: {
+      type: "boolean",
+      default: false
+    },
+    minimum: {
+      type: "number"
+    },
+    exclusiveMinimum: {
+      type: "boolean",
+      default: false
+    },
+    maxLength: { $ref: "#/definitions/positiveInteger" },
+    minLength: { $ref: "#/definitions/positiveIntegerDefault0" },
+    pattern: {
+      type: "string",
+      format: "regex"
+    },
+    additionalItems: {
+      anyOf: [{ type: "boolean" }, { $ref: "#" }],
+      default: {}
+    },
+    items: {
+      anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
+      default: {}
+    },
+    maxItems: { $ref: "#/definitions/positiveInteger" },
+    minItems: { $ref: "#/definitions/positiveIntegerDefault0" },
+    uniqueItems: {
+      type: "boolean",
+      default: false
+    },
+    maxProperties: { $ref: "#/definitions/positiveInteger" },
+    minProperties: { $ref: "#/definitions/positiveIntegerDefault0" },
+    required: { $ref: "#/definitions/stringArray" },
+    additionalProperties: {
+      anyOf: [{ type: "boolean" }, { $ref: "#" }],
+      default: {}
+    },
+    definitions: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    properties: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    patternProperties: {
+      type: "object",
+      additionalProperties: { $ref: "#" },
+      default: {}
+    },
+    dependencies: {
+      type: "object",
+      additionalProperties: {
+        anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
+      }
+    },
+    enum: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true
+    },
+    type: {
+      anyOf: [
+        { $ref: "#/definitions/simpleTypes" },
+        {
+          type: "array",
+          items: { $ref: "#/definitions/simpleTypes" },
+          minItems: 1,
+          uniqueItems: true
+        }
+      ]
+    },
+    allOf: { $ref: "#/definitions/schemaArray" },
+    anyOf: { $ref: "#/definitions/schemaArray" },
+    oneOf: { $ref: "#/definitions/schemaArray" },
+    not: { $ref: "#" }
+  },
+  dependencies: {
+    exclusiveMaximum: ["maximum"],
+    exclusiveMinimum: ["minimum"]
+  },
+  default: {}
+};
 var RuleEffect;
 (function(RuleEffect2) {
   RuleEffect2["HIDE"] = "HIDE";
@@ -319,6 +502,28 @@ var RuleEffect;
   RuleEffect2["ENABLE"] = "ENABLE";
   RuleEffect2["DISABLE"] = "DISABLE";
 })(RuleEffect || (RuleEffect = {}));
+const setReadonlyPropertyValue = (value) => (child) => {
+  if (!child.options) {
+    child.options = {};
+  }
+  child.options.readonly = value;
+};
+const setReadonly = (uischema) => {
+  iterateSchema(uischema, setReadonlyPropertyValue(true));
+};
+const unsetReadonly = (uischema) => {
+  iterateSchema(uischema, setReadonlyPropertyValue(false));
+};
+const iterateSchema = (uischema, toApply) => {
+  if (isEmpty(uischema)) {
+    return;
+  }
+  if (isLayout(uischema)) {
+    uischema.elements.forEach((child) => iterateSchema(child, toApply));
+    return;
+  }
+  toApply(uischema);
+};
 const findUiControl = (uiSchema, path) => {
   var _a;
   if (isControlElement(uiSchema)) {
@@ -353,6 +558,7 @@ const isLayout = (uischema) => uischema.elements !== void 0;
 const isScopable = (obj) => !!obj && typeof obj === "object";
 const isScoped = (obj) => isScopable(obj) && typeof obj.scope === "string";
 const isLabelable = (obj) => !!obj && typeof obj === "object";
+const isLabeled = (obj) => isLabelable(obj) && ["string", "boolean"].includes(typeof obj.label);
 const isControlElement = (uiSchema) => uiSchema.type === "Control";
 const isOrCondition = (condition) => condition.type === "OR";
 const isAndCondition = (condition) => condition.type === "AND";
@@ -462,6 +668,7 @@ const convertDateToString = (date, format) => {
   }
   return dateString;
 };
+const convertToValidClassName = (s) => s.replace("#", "root").replace(new RegExp("/", "g"), "_");
 const hasType = (jsonSchema, expected) => {
   return includes(deriveTypes(jsonSchema), expected);
 };
@@ -509,6 +716,14 @@ const Paths = {
   compose,
   fromScoped
 };
+const Runtime = {
+  isEnabled(uischema, data, ajv, config) {
+    return isEnabled(uischema, data, void 0, ajv, config);
+  },
+  isVisible(uischema, data, ajv, config) {
+    return isVisible(uischema, data, void 0, ajv, config);
+  }
+};
 const createAjv = (options) => {
   const ajv = new Ajv({
     allErrors: true,
@@ -530,6 +745,9 @@ const validate = (validator, data) => {
   }
   return validator.errors;
 };
+const defaultDateFormat = "YYYY-MM-DD";
+const defaultTimeFormat = "HH:mm:ss";
+const defaultDateTimeFormat = "YYYY-MM-DDTHH:mm:ss.sssZ";
 const getInvalidProperty = (error) => {
   switch (error.keyword) {
     case "required":
@@ -582,6 +800,10 @@ const formatErrorMessage = (errors) => {
   }
   return errors.join("\n");
 };
+const Helpers = {
+  createLabelDescriptionFrom,
+  convertToValidClassName
+};
 const createLayout = (layoutType) => ({
   type: layoutType,
   elements: []
@@ -862,6 +1084,16 @@ var index$1 = /* @__PURE__ */ Object.freeze({
   updateI18n,
   setUISchema
 });
+const cellReducer = (state = [], { type, tester, cell }) => {
+  switch (type) {
+    case ADD_CELL:
+      return state.concat([{ tester, cell }]);
+    case REMOVE_CELL:
+      return state.filter((t) => t.tester !== tester);
+    default:
+      return state;
+  }
+};
 const configDefault = {
   restrict: false,
   trim: false,
@@ -1066,6 +1298,20 @@ const coreReducer = (state = initState, action) => {
       return state;
   }
 };
+const defaultDataReducer = (state = [], action) => {
+  switch (action.type) {
+    case ADD_DEFAULT_DATA:
+      return state.concat([
+        { schemaPath: action.schemaPath, data: action.data }
+      ]);
+    case REMOVE_DEFAULT_DATA:
+      return state.filter((t) => t.schemaPath !== action.schemaPath);
+    default:
+      return state;
+  }
+};
+const getDefaultData = (state) => extractDefaultData(get(state, "jsonforms.defaultData"));
+const extractDefaultData = (state) => state;
 var ArrayTranslationEnum;
 (function(ArrayTranslationEnum2) {
   ArrayTranslationEnum2["addTooltip"] = "addTooltip";
@@ -1118,7 +1364,7 @@ var CombinatorTranslationEnum;
   CombinatorTranslationEnum2["clearDialogAccept"] = "clearDialogAccept";
   CombinatorTranslationEnum2["clearDialogDecline"] = "clearDialogDecline";
 })(CombinatorTranslationEnum || (CombinatorTranslationEnum = {}));
-[
+const combinatorDefaultTranslations = [
   {
     key: CombinatorTranslationEnum.clearDialogTitle,
     default: () => "Clear form?"
@@ -1206,6 +1452,20 @@ const getArrayTranslations = (t, defaultTranslations, i18nKeyPrefix, label) => {
   });
   return translations;
 };
+const getCombinatorTranslations = (t, defaultTranslations, i18nKeyPrefix, label) => {
+  const translations = {};
+  defaultTranslations.forEach((controlElement) => {
+    const key = addI18nKeyToPrefix(i18nKeyPrefix, controlElement.key);
+    translations[controlElement.key] = t(key, controlElement.default(label));
+  });
+  return translations;
+};
+const fetchLocale = (state) => {
+  if (state === void 0) {
+    return void 0;
+  }
+  return state.locale;
+};
 const fetchTranslator = (state) => {
   if (state === void 0) {
     return defaultTranslator;
@@ -1218,6 +1478,7 @@ const fetchErrorTranslator = (state) => {
   }
   return state.translateError;
 };
+const getLocale = (state) => fetchLocale(get(state, "jsonforms.i18n"));
 const getTranslator = () => (state) => fetchTranslator(get(state, "jsonforms.i18n"));
 const getErrorTranslator = () => (state) => fetchErrorTranslator(get(state, "jsonforms.i18n"));
 const defaultJsonFormsI18nState = {
@@ -1256,6 +1517,18 @@ const i18nReducer = (state = defaultJsonFormsI18nState, action) => {
       return state;
   }
 };
+const rendererReducer = (state = [], action) => {
+  switch (action.type) {
+    case ADD_RENDERER:
+      return state.concat([
+        { tester: action.tester, renderer: action.renderer }
+      ]);
+    case REMOVE_RENDERER:
+      return state.filter((t) => t.tester !== action.tester);
+    default:
+      return state;
+  }
+};
 const NOT_APPLICABLE = -1;
 const isControl = (uischema) => !isEmpty(uischema) && uischema.scope !== void 0;
 const schemaMatches = (predicate) => (uischema, schema, context) => {
@@ -1303,6 +1576,26 @@ const optionIs = (optionName, optionValue) => (uischema) => {
   const options = uischema.options;
   return !isEmpty(options) && options[optionName] === optionValue;
 };
+const hasOption = (optionName) => (uischema) => {
+  if (isEmpty(uischema)) {
+    return false;
+  }
+  const options = uischema.options;
+  return !isEmpty(options) && !isUndefined(options[optionName]);
+};
+const scopeEndsWith = (expected) => (uischema) => {
+  if (isEmpty(expected) || !isControl(uischema)) {
+    return false;
+  }
+  return endsWith(uischema.scope, expected);
+};
+const scopeEndIs = (expected) => (uischema) => {
+  if (isEmpty(expected) || !isControl(uischema)) {
+    return false;
+  }
+  const schemaPath = uischema.scope;
+  return !isEmpty(schemaPath) && last(schemaPath.split("/")) === expected;
+};
 const and = (...testers) => (uischema, schema, context) => testers.reduce((acc, tester) => acc && tester(uischema, schema, context), true);
 const or = (...testers) => (uischema, schema, context) => testers.reduce((acc, tester) => acc || tester(uischema, schema, context), false);
 const rankWith = (rank, tester) => (uischema, schema, context) => {
@@ -1311,17 +1604,24 @@ const rankWith = (rank, tester) => (uischema, schema, context) => {
   }
   return NOT_APPLICABLE;
 };
+const withIncreasedRank = (by, rankedTester) => (uischema, schema, context) => {
+  const rank = rankedTester(uischema, schema, context);
+  if (rank === NOT_APPLICABLE) {
+    return NOT_APPLICABLE;
+  }
+  return rank + by;
+};
 const isBooleanControl = and(uiTypeIs("Control"), schemaTypeIs("boolean"));
 const isObjectControl = and(uiTypeIs("Control"), schemaTypeIs("object"));
-and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "allOf")));
-and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "anyOf")));
+const isAllOfControl = and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "allOf")));
+const isAnyOfControl = and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "anyOf")));
 const isOneOfControl = and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "oneOf")));
 const isEnumControl = and(uiTypeIs("Control"), schemaMatches((schema) => isEnumSchema(schema)));
-and(uiTypeIs("Control"), schemaMatches((schema) => isOneOfEnumSchema(schema)));
+const isOneOfEnumControl = and(uiTypeIs("Control"), schemaMatches((schema) => isOneOfEnumSchema(schema)));
 const isIntegerControl = and(uiTypeIs("Control"), schemaTypeIs("integer"));
 const isNumberControl = and(uiTypeIs("Control"), schemaTypeIs("number"));
 const isStringControl = and(uiTypeIs("Control"), schemaTypeIs("string"));
-and(uiTypeIs("Control"), optionIs("multi", true));
+const isMultiLineControl = and(uiTypeIs("Control"), optionIs("multi", true));
 const isDateControl = and(uiTypeIs("Control"), or(formatIs("date"), optionIs("format", "date")));
 const isTimeControl = and(uiTypeIs("Control"), or(formatIs("time"), optionIs("format", "time")));
 const isDateTimeControl = and(uiTypeIs("Control"), or(formatIs("date-time"), optionIs("format", "date-time")));
@@ -1397,6 +1697,7 @@ const isObjectArrayWithNesting = (uischema, schema, context) => {
   }
   return false;
 };
+const isArrayObjectControl = isObjectArrayControl;
 const isPrimitiveArrayControl = and(uiTypeIs("Control"), schemaMatches(
   (schema, rootSchema) => deriveTypes(schema).length !== 0 && !Array.isArray(resolveSchema(schema, "items", rootSchema))
 ), schemaSubPathMatches("items", (schema, rootSchema) => {
@@ -1404,8 +1705,75 @@ const isPrimitiveArrayControl = and(uiTypeIs("Control"), schemaMatches(
   const types = deriveTypes(resolvedSchema);
   return types.length === 1 && includes(["integer", "number", "boolean", "string"], types[0]);
 }));
-and(uiTypeIs("Control"), or(schemaTypeIs("number"), schemaTypeIs("integer")), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "maximum") && Object.prototype.hasOwnProperty.call(schema, "minimum") && Object.prototype.hasOwnProperty.call(schema, "default")), optionIs("slider", true));
-and(uiTypeIs("Control"), schemaTypeIs("integer"), optionIs("format", true));
+const isRangeControl = and(uiTypeIs("Control"), or(schemaTypeIs("number"), schemaTypeIs("integer")), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "maximum") && Object.prototype.hasOwnProperty.call(schema, "minimum") && Object.prototype.hasOwnProperty.call(schema, "default")), optionIs("slider", true));
+const isNumberFormatControl = and(uiTypeIs("Control"), schemaTypeIs("integer"), optionIs("format", true));
+const isCategorization = (category) => category.type === "Categorization";
+const isCategory = (uischema) => uischema.type === "Category";
+const hasCategory = (categorization) => {
+  if (isEmpty(categorization.elements)) {
+    return false;
+  }
+  return categorization.elements.map((elem) => isCategorization(elem) ? hasCategory(elem) : isCategory(elem)).reduce((prev, curr) => prev && curr, true);
+};
+const categorizationHasCategory = (uischema) => hasCategory(uischema);
+const not = (tester) => (uischema, schema, context) => !tester(uischema, schema, context);
+var index = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  NOT_APPLICABLE,
+  isControl,
+  schemaMatches,
+  schemaSubPathMatches,
+  schemaTypeIs,
+  formatIs,
+  uiTypeIs,
+  optionIs,
+  hasOption,
+  scopeEndsWith,
+  scopeEndIs,
+  and,
+  or,
+  rankWith,
+  withIncreasedRank,
+  isBooleanControl,
+  isObjectControl,
+  isAllOfControl,
+  isAnyOfControl,
+  isOneOfControl,
+  isEnumControl,
+  isOneOfEnumControl,
+  isIntegerControl,
+  isNumberControl,
+  isStringControl,
+  isMultiLineControl,
+  isDateControl,
+  isTimeControl,
+  isDateTimeControl,
+  isObjectArray,
+  isObjectArrayControl,
+  isObjectArrayWithNesting,
+  isArrayObjectControl,
+  isPrimitiveArrayControl,
+  isRangeControl,
+  isNumberFormatControl,
+  isCategorization,
+  isCategory,
+  hasCategory,
+  categorizationHasCategory,
+  not
+});
+const uischemaRegistryReducer = (state = [], action) => {
+  switch (action.type) {
+    case ADD_UI_SCHEMA:
+      return state.slice().concat({ tester: action.tester, uischema: action.uischema });
+    case REMOVE_UI_SCHEMA: {
+      const copy = state.slice();
+      remove(copy, (entry) => entry.tester === action.tester);
+      return copy;
+    }
+    default:
+      return state;
+  }
+};
 const findMatchingUISchema = (state) => (jsonSchema, schemaPath, path) => {
   const match = maxBy(state, (entry) => entry.tester(jsonSchema, schemaPath, path));
   if (match !== void 0 && match.tester(jsonSchema, schemaPath, path) !== NOT_APPLICABLE) {
@@ -1413,6 +1781,15 @@ const findMatchingUISchema = (state) => (jsonSchema, schemaPath, path) => {
   }
   return void 0;
 };
+const jsonFormsReducerConfig = {
+  core: coreReducer,
+  renderers: rendererReducer,
+  cells: cellReducer,
+  config: configReducer,
+  uischemas: uischemaRegistryReducer,
+  defaultData: defaultDataReducer,
+  i18n: i18nReducer
+};
 const findUISchema = (uischemas, schema, schemaPath, path, fallback = "VerticalLayout", control, rootSchema) => {
   if (control && control.options && control.options.detail) {
     if (typeof control.options.detail === "string") {
@@ -1455,6 +1832,7 @@ const getUiSchema = (state) => extractUiSchema(get(state, "jsonforms.core"));
 const getAjv = (state) => extractAjv(get(state, "jsonforms.core"));
 const getRenderers = (state) => get(state, "jsonforms.renderers");
 const getCells = (state) => get(state, "jsonforms.cells");
+const getUISchemas = (state) => get(state, "jsonforms.uischemas");
 const extractData = (state) => get(state, "data");
 const extractSchema = (state) => get(state, "schema");
 const extractUiSchema = (state) => get(state, "uischema");
@@ -1488,12 +1866,12 @@ const isInherentlyEnabled = (state, ownProps, uischema, schema, rootData, config
   }
   return true;
 };
-const move = (array, index, delta) => {
-  const newIndex = index + delta;
+const move = (array, index2, delta) => {
+  const newIndex = index2 + delta;
   if (newIndex < 0 || newIndex >= array.length) {
     return;
   }
-  const indexes = [index, newIndex].sort((a, b) => a - b);
+  const indexes = [index2, newIndex].sort((a, b) => a - b);
   array.splice(indexes[0], 2, array[indexes[1]], array[indexes[0]]);
 };
 const moveUp = (array, toMove) => {
@@ -1513,6 +1891,9 @@ const isRequired = (schema, schemaPath, rootSchema) => {
 const computeLabel = (label, required, hideRequiredAsterisk) => {
   return `${label ?? ""}${required && !hideRequiredAsterisk ? "*" : ""}`;
 };
+const showAsRequired = (required, hideRequiredAsterisk) => {
+  return required && !hideRequiredAsterisk;
+};
 const createDefaultValue = (schema, rootSchema) => {
   const defaultValue = doCreateDefaultValue(schema, rootSchema);
   return defaultValue === void 0 ? {} : defaultValue;
@@ -1592,6 +1973,9 @@ const extractDefaults = (schema, rootSchema) => {
   }
   return cloneDeep(schema.default);
 };
+const isDescriptionHidden = (visible, description, isFocused, showUnfocusedDescription) => {
+  return description === void 0 || description !== void 0 && !visible || !showUnfocusedDescription && !isFocused;
+};
 const enumToEnumOptionMapper = (e, t, i18nKey) => {
   let label = typeof e === "string" ? e : JSON.stringify(e);
   if (t) {
@@ -1708,6 +2092,15 @@ const mapStateToMultiEnumControlProps = (state, ownProps) => {
     options
   };
 };
+const mapStateToMasterListItemProps = (state, ownProps) => {
+  const { schema, path, uischema, childLabelProp, index: index2 } = ownProps;
+  const childPath = compose(path, `${index2}`);
+  const childLabel = computeChildLabel(getData(state), childPath, childLabelProp, schema, getSchema(state), state.jsonforms.i18n.translate, uischema);
+  return {
+    ...ownProps,
+    childLabel
+  };
+};
 const mapStateToControlWithDetailProps = (state, ownProps) => {
   const { ...props } = mapStateToControlProps(state, ownProps);
   return {
@@ -1715,6 +2108,22 @@ const mapStateToControlWithDetailProps = (state, ownProps) => {
     uischemas: state.jsonforms.uischemas
   };
 };
+const mapStateToArrayControlProps = (state, ownProps) => {
+  const { path, schema, uischema, label, ...props } = mapStateToControlWithDetailProps(state, ownProps);
+  const resolvedSchema = Resolve.schema(schema, "items", props.rootSchema);
+  const childErrors = getSubErrorsAt(path, resolvedSchema)(state);
+  return {
+    ...props,
+    label,
+    path,
+    uischema,
+    schema: resolvedSchema,
+    arraySchema: schema,
+    childErrors,
+    renderers: ownProps.renderers || getRenderers(state),
+    cells: ownProps.cells || getCells(state)
+  };
+};
 const mapDispatchToArrayControlProps = (dispatch) => ({
   addItem: (path, value) => () => {
     dispatch(update(path, (array) => {
@@ -1826,6 +2235,59 @@ const mapStateToJsonFormsRendererProps = (state, ownProps) => {
     config: getConfig(state)
   };
 };
+const controlDefaultProps = {
+  ...layoutDefaultProps,
+  errors: []
+};
+const mapStateToCombinatorRendererProps = (state, ownProps, keyword) => {
+  var _a;
+  const { data, schema, rootSchema, i18nKeyPrefix, label, ...props } = mapStateToControlProps(state, ownProps);
+  const ajv = state.jsonforms.core.ajv;
+  const structuralKeywords = [
+    "required",
+    "additionalProperties",
+    "type",
+    "enum",
+    "const"
+  ];
+  const dataIsValid = (errors) => {
+    return !errors || errors.length === 0 || !errors.find((e) => structuralKeywords.indexOf(e.keyword) !== -1);
+  };
+  let indexOfFittingSchema;
+  for (let i = 0; i < ((_a = schema[keyword]) == null ? void 0 : _a.length); i++) {
+    try {
+      let _schema = schema[keyword][i];
+      if (_schema.$ref) {
+        _schema = Resolve.schema(rootSchema, _schema.$ref, rootSchema);
+      }
+      const valFn = ajv.compile(_schema);
+      valFn(data);
+      if (dataIsValid(valFn.errors)) {
+        indexOfFittingSchema = i;
+        break;
+      }
+    } catch (error) {
+      console.debug("Combinator subschema is not self contained, can't hand it over to AJV");
+    }
+  }
+  return {
+    data,
+    schema,
+    rootSchema,
+    ...props,
+    i18nKeyPrefix,
+    label,
+    indexOfFittingSchema,
+    uischemas: getUISchemas(state)
+  };
+};
+const mapStateToAllOfProps = (state, ownProps) => mapStateToCombinatorRendererProps(state, ownProps, "allOf");
+const mapStateToAnyOfProps = (state, ownProps) => {
+  return mapStateToCombinatorRendererProps(state, ownProps, "anyOf");
+};
+const mapStateToOneOfProps = (state, ownProps) => {
+  return mapStateToCombinatorRendererProps(state, ownProps, "oneOf");
+};
 const mapStateToArrayLayoutProps = (state, ownProps) => {
   const { path, schema, uischema, errors, label, ...props } = mapStateToControlWithDetailProps(state, ownProps);
   const resolvedSchema = Resolve.schema(schema, "items", props.rootSchema);
@@ -1949,6 +2411,22 @@ const mapStateToOneOfEnumCellProps = (state, ownProps) => {
     options
   };
 };
+const mapDispatchToCellProps = mapDispatchToControlProps;
+const defaultMapDispatchToControlProps = (dispatch, ownProps) => {
+  const { handleChange } = mapDispatchToCellProps(dispatch);
+  return {
+    handleChange: ownProps.handleChange || handleChange
+  };
+};
+const createCombinatorRenderInfos = (combinatorSubSchemas, rootSchema, keyword, control, path, uischemas) => combinatorSubSchemas.map((subSchema, subSchemaIndex) => {
+  const resolvedSubSchema = subSchema.$ref && Resolve.schema(rootSchema, subSchema.$ref, rootSchema);
+  const schema = resolvedSubSchema ?? subSchema;
+  return {
+    schema,
+    uischema: findUISchema(uischemas, schema, control.scope, path, void 0, control, rootSchema),
+    label: subSchema.title ?? (resolvedSubSchema == null ? void 0 : resolvedSubSchema.title) ?? `${keyword}-${subSchemaIndex}`
+  };
+});
 export {
   ADD_CELL,
   ADD_DEFAULT_DATA,
@@ -1957,7 +2435,9 @@ export {
   index$1 as Actions,
   ArrayTranslationEnum,
   CombinatorTranslationEnum,
+  Draft4,
   Generate,
+  Helpers,
   INIT,
   NOT_APPLICABLE,
   Paths,
@@ -1967,6 +2447,7 @@ export {
   REMOVE_UI_SCHEMA,
   Resolve,
   RuleEffect,
+  Runtime,
   SET_AJV,
   SET_CONFIG,
   SET_LOCALE,
@@ -1974,6 +2455,7 @@ export {
   SET_TRANSLATOR,
   SET_UISCHEMA,
   SET_VALIDATION_MODE,
+  index as Test,
   UPDATE_CORE,
   UPDATE_DATA,
   UPDATE_ERRORS,
@@ -1982,24 +2464,37 @@ export {
   addI18nKeyToPrefix,
   and,
   arrayDefaultTranslations,
+  categorizationHasCategory,
+  cellReducer,
+  clearAllIds,
+  combinatorDefaultTranslations,
   compose,
   compose as composePaths,
   composeWithUi,
   computeChildLabel,
   computeLabel,
   configReducer,
+  controlDefaultProps,
   convertDateToString,
+  convertToValidClassName,
   coreReducer,
   createAjv,
+  createCleanLabel,
+  createCombinatorRenderInfos,
   createControlElement,
   createDefaultValue,
   createId,
   createLabelDescriptionFrom,
   decode,
+  defaultDataReducer,
+  defaultDateFormat,
+  defaultDateTimeFormat,
   defaultErrorTranslator,
   defaultJsonFormsI18nState,
+  defaultMapDispatchToControlProps,
   defaultMapStateToEnumCellProps,
   defaultMiddleware,
+  defaultTimeFormat,
   defaultTranslator,
   deriveLabelForUISchemaElement,
   deriveTypes,
@@ -2012,11 +2507,14 @@ export {
   evalVisibility,
   extractAjv,
   extractData,
+  extractDefaultData,
   extractDefaults,
   extractSchema,
   extractUiSchema,
   fetchErrorTranslator,
+  fetchLocale,
   fetchTranslator,
+  findAllRefs,
   findMatchingUISchema,
   findUISchema,
   findUiControl,
@@ -2028,35 +2526,47 @@ export {
   getAjv,
   getArrayTranslations,
   getCells,
+  getCombinatorTranslations,
   getCombinedErrorMessage,
   getConfig,
   getControlPath,
   getData,
+  getDefaultData,
   getErrorAt,
   getErrorTranslator,
   getFirstPrimitiveProp,
   getI18nKey,
   getI18nKeyPrefix,
   getI18nKeyPrefixBySchema,
+  getLocale,
   getOrCreateAjv,
   getPropPath,
   getRenderers,
   getSchema,
   getSubErrorsAt,
   getTranslator,
+  getUISchemas,
   getUiSchema,
   getValidationMode,
+  hasCategory,
   hasEnableRule,
+  hasOption,
   hasShowRule,
   hasType,
   i18nReducer,
   init,
   initState,
+  isAllOfControl,
+  isAnyOfControl,
+  isArrayObjectControl,
   isBooleanControl,
+  isCategorization,
+  isCategory,
   isControl,
   isControlElement,
   isDateControl,
   isDateTimeControl,
+  isDescriptionHidden,
   isEnabled,
   isEnumControl,
   isEnumSchema,
@@ -2065,27 +2575,39 @@ export {
   isIntegerControl,
   isInternationalized,
   isLabelable,
+  isLabeled,
   isLayout,
+  isMultiLineControl,
   isNumberControl,
+  isNumberFormatControl,
   isObjectArray,
   isObjectArrayControl,
   isObjectArrayWithNesting,
   isObjectControl,
   isOneOfControl,
+  isOneOfEnumControl,
   isOneOfEnumSchema,
   isPrimitiveArrayControl,
+  isRangeControl,
   isScopable,
   isScoped,
   isStringControl,
   isTimeControl,
   isUpdateArrayContext,
   isVisible,
+  iterateSchema,
+  jsonFormsReducerConfig,
   layoutDefaultProps,
   mapDispatchToArrayControlProps,
+  mapDispatchToCellProps,
   mapDispatchToControlProps,
   mapDispatchToMultiEnumProps,
+  mapStateToAllOfProps,
+  mapStateToAnyOfProps,
+  mapStateToArrayControlProps,
   mapStateToArrayLayoutProps,
   mapStateToCellProps,
+  mapStateToCombinatorRendererProps,
   mapStateToControlProps,
   mapStateToControlWithDetailProps,
   mapStateToDispatchCellProps,
@@ -2093,11 +2615,14 @@ export {
   mapStateToJsonFormsRendererProps,
   mapStateToLabelProps,
   mapStateToLayoutProps,
+  mapStateToMasterListItemProps,
   mapStateToMultiEnumControlProps,
   mapStateToOneOfEnumCellProps,
   mapStateToOneOfEnumControlProps,
+  mapStateToOneOfProps,
   moveDown,
   moveUp,
+  not,
   oneOfToEnumOptionMapper,
   optionIs,
   or,
@@ -2107,29 +2632,38 @@ export {
   registerRenderer,
   registerUISchema,
   removeId,
+  rendererReducer,
   resolveData,
   resolveSchema,
   schemaMatches,
   schemaSubPathMatches,
   schemaTypeIs,
+  scopeEndIs,
+  scopeEndsWith,
   setAjv,
   setConfig,
   setLocale,
+  setReadonly,
   setSchema,
   setTranslator,
   setUISchema,
   setValidationMode,
+  showAsRequired,
   subErrorsAt,
+  toDataPath,
   toDataPathSegments,
   transformPathToI18nPrefix,
   uiTypeIs,
+  uischemaRegistryReducer,
   unregisterCell,
   unregisterDefaultData,
   unregisterRenderer,
   unregisterUISchema,
+  unsetReadonly,
   update,
   updateCore,
   updateErrors,
   updateI18n,
-  validate
+  validate,
+  withIncreasedRank
 };