fastapi-rtk 0.1.12 → 0.1.14

package/dist/jsonforms/esm/cells/MantineJsonCell.mjs

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith } from "@jsonforms/core";
+import { withJsonFormsCellProps } from "@jsonforms/react";
+import { MantineJsonInput } from "../MantineInputs/MantineJsonInput.mjs";
+import { isJsonControl } from "../testers/isJsonControl.mjs";
+const mantineJsonCellTester = rankWith(2, isJsonControl);
+const MantineJsonCell = withJsonFormsCellProps((props) => /* @__PURE__ */ jsx(MantineJsonInput, { ...props }));
+export {
+  MantineJsonCell,
+  mantineJsonCellTester
+};

package/dist/jsonforms/esm/cells/MantineNumberCell.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isNumberControl } from "@jsonforms/core";
+import { withJsonFormsCellProps } from "@jsonforms/react";
+import { MantineNumberInput } from "../MantineInputs/MantineNumberInput.mjs";
+const mantineNumberCellTester = rankWith(1, isNumberControl);
+const MantineNumberCell = withJsonFormsCellProps((props) => /* @__PURE__ */ jsx(MantineNumberInput, { ...props }));
+export {
+  MantineNumberCell,
+  mantineNumberCellTester
+};

package/dist/jsonforms/esm/cells/MantineOneOfEnumCell.mjs

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isOneOfControl } from "@jsonforms/core";
+import { withJsonFormsOneOfEnumCellProps, withTranslateProps } from "@jsonforms/react";
+import { MantineOneOfEnumInput } from "../MantineInputs/MantineOneOfEnumInput.mjs";
+const mantineOneOfEnumCellTester = rankWith(2, isOneOfControl);
+const MantineOneOfEnumCell = withJsonFormsOneOfEnumCellProps(
+  withTranslateProps((props) => /* @__PURE__ */ jsx(MantineOneOfEnumInput, { ...props })),
+  false
+);
+export {
+  MantineOneOfEnumCell,
+  mantineOneOfEnumCellTester
+};

package/dist/jsonforms/esm/cells/MantineTextCell.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isStringControl } from "@jsonforms/core";
+import { withJsonFormsCellProps } from "@jsonforms/react";
+import { MantineTextInput } from "../MantineInputs/MantineTextInput.mjs";
+const mantineTextCellTester = rankWith(1, isStringControl);
+const MantineTextCell = withJsonFormsCellProps((props) => /* @__PURE__ */ jsx(MantineTextInput, { ...props }));
+export {
+  MantineTextCell,
+  mantineTextCellTester
+};

package/dist/jsonforms/esm/complex/MantineArrayControl/DeleteDialog.mjs

@@ -0,0 +1,24 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Modal, Stack, Text, Flex, Button } from "@mantine/core";
+import React from "react";
+const DeleteDialog = React.memo(function DeleteDialog2({
+  open,
+  onClose,
+  onConfirm,
+  onCancel,
+  title,
+  message,
+  acceptText,
+  declineText
+}) {
+  return /* @__PURE__ */ jsx(Modal, { opened: open, withCloseButton: false, centered: true, title, keepMounted: true, onClose, children: /* @__PURE__ */ jsxs(Stack, { children: [
+    /* @__PURE__ */ jsx(Text, { children: message }),
+    /* @__PURE__ */ jsxs(Flex, { justify: "flex-end", align: "center", gap: "md", children: [
+      /* @__PURE__ */ jsx(Button, { onClick: onCancel, children: declineText }),
+      /* @__PURE__ */ jsx(Button, { onClick: onConfirm, children: acceptText })
+    ] })
+  ] }) });
+});
+export {
+  DeleteDialog
+};

package/dist/jsonforms/esm/complex/MantineArrayControl/MantineArrayControl.mjs

@@ -0,0 +1,59 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { rankWith, or, isObjectArrayControl, isPrimitiveArrayControl } from "@jsonforms/core";
+import { withJsonFormsArrayLayoutProps, withTranslateProps, withArrayTranslationProps } from "@jsonforms/react";
+import { useState, useCallback } from "react";
+import { isEnumArrayArrayControl } from "../../testers/isEnumArrayArrayControl.mjs";
+import { isJsonArrayControl } from "../../testers/isJsonArrayControl.mjs";
+import { MantineTableControl } from "../MantineTableControl/MantineTableControl.mjs";
+import { DeleteDialog } from "./DeleteDialog.mjs";
+const Component = (props) => {
+  const [open, setOpen] = useState(false);
+  const [path, setPath] = useState(void 0);
+  const [rowData, setRowData] = useState(void 0);
+  const { removeItems, visible } = props;
+  const openDeleteDialog = useCallback(
+    (p, rowIndex) => {
+      setOpen(true);
+      setPath(p);
+      setRowData(rowIndex);
+    },
+    [setOpen, setPath, setRowData]
+  );
+  const deleteCancel = useCallback(() => setOpen(false), [setOpen]);
+  const deleteConfirm = useCallback(() => {
+    const p = path.substring(0, path.lastIndexOf("."));
+    removeItems(p, [rowData])();
+    setOpen(false);
+  }, [path, removeItems, rowData]);
+  const deleteClose = useCallback(() => setOpen(false), [setOpen]);
+  if (!visible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(MantineTableControl, { ...props, openDeleteDialog }),
+    /* @__PURE__ */ jsx(
+      DeleteDialog,
+      {
+        open,
+        onCancel: deleteCancel,
+        onConfirm: deleteConfirm,
+        onClose: deleteClose,
+        acceptText: props.translations.deleteDialogAccept,
+        declineText: props.translations.deleteDialogDecline,
+        title: props.translations.deleteDialogTitle,
+        message: props.translations.deleteDialogMessage
+      }
+    )
+  ] });
+};
+const mantineArrayControlTester = rankWith(
+  1,
+  or(isObjectArrayControl, isPrimitiveArrayControl, isEnumArrayArrayControl, isJsonArrayControl)
+);
+const MantineArrayControlRenderer = withJsonFormsArrayLayoutProps(
+  withTranslateProps(withArrayTranslationProps(Component))
+);
+export {
+  MantineArrayControlRenderer,
+  mantineArrayControlTester
+};

package/dist/jsonforms/esm/complex/MantineEnumArrayControl.mjs

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith } from "@jsonforms/core";
+import { withJsonFormsMultiEnumProps } from "@jsonforms/react";
+import { MantineEnumArrayInput } from "../MantineInputs/MantineEnumArrayInput.mjs";
+import { isEnumArrayControl } from "../testers/isEnumArrayControl.mjs";
+const mantineEnumArrayRendererTester = rankWith(1, isEnumArrayControl);
+const MantineEnumArrayRenderer = withJsonFormsMultiEnumProps((props) => /* @__PURE__ */ jsx(MantineEnumArrayInput, { ...props }));
+export {
+  MantineEnumArrayRenderer,
+  mantineEnumArrayRendererTester
+};

package/dist/jsonforms/esm/complex/MantineObjectControl.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isObjectControl } from "@jsonforms/core";
+import { withJsonFormsDetailProps } from "@jsonforms/react";
+import { MantineObjectInput } from "../MantineInputs/MantineObjectInput.mjs";
+const MantineObjectControlTester = rankWith(1, isObjectControl);
+const MantineObjectControl = withJsonFormsDetailProps((props) => /* @__PURE__ */ jsx(MantineObjectInput, { ...props }));
+export {
+  MantineObjectControl,
+  MantineObjectControlTester
+};

package/dist/jsonforms/esm/complex/MantineTableControl/MantineTableControl.mjs

@@ -0,0 +1,358 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { deepMerge } from "fastapi-rtk/utils";
+import { Resolve, encode, Paths, formatErrorMessage, errorsAt } from "@jsonforms/core";
+import { DispatchCell, useJsonForms } from "@jsonforms/react";
+import { Table, useProps, MantineThemeProvider, Text, Grid, ActionIcon } from "@mantine/core";
+import isEmpty from "../../_virtual/isEmpty.mjs";
+import merge from "../../_virtual/merge.mjs";
+import range from "../../_virtual/range.mjs";
+import startCase from "../../_virtual/startCase.mjs";
+import union from "../../_virtual/union.mjs";
+import React, { useMemo, memo } from "react";
+import { useContextProps } from "../../hooks/useContextProps.mjs";
+import { useThemeCustomizer } from "../../hooks/useThemeCustomizer.mjs";
+import { NoBorderTableCell } from "./NoBorderTableCell.mjs";
+import { TableToolbar } from "./TableToolbar.mjs";
+import IconArrowUp from "../../../../external/esm/@tabler_icons-react@3.18.0_react@18.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconArrowUp.mjs";
+import IconArrowDown from "../../../../external/esm/@tabler_icons-react@3.18.0_react@18.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconArrowDown.mjs";
+import IconTrash from "../../../../external/esm/@tabler_icons-react@3.18.0_react@18.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconTrash.mjs";
+const isValidObjectSchema = (schema) => schema.type === "object" && typeof schema.properties === "object";
+const styles = {
+  fixedCell: {
+    width: "150px",
+    height: "50px",
+    paddingLeft: 0,
+    paddingRight: 0,
+    textAlign: "center"
+  },
+  fixedCellSmall: {
+    width: "50px",
+    height: "50px",
+    paddingLeft: 0,
+    paddingRight: 0,
+    textAlign: "center"
+  }
+};
+const generateCells = (Cell, schema, rowPath, enabled, cells) => {
+  if (isValidObjectSchema(schema)) {
+    return getValidColumnProps(schema).map((prop, index) => {
+      var _a, _b;
+      const cellPath = Paths.compose(rowPath, prop);
+      const props = {
+        propName: prop,
+        schema,
+        title: ((_b = (_a = schema.properties) == null ? void 0 : _a[prop]) == null ? void 0 : _b.title) ?? startCase(prop),
+        rowPath,
+        cellPath,
+        enabled,
+        cells,
+        index
+      };
+      return /* @__PURE__ */ jsx(Cell, { ...props }, cellPath);
+    });
+  } else {
+    const props = {
+      schema,
+      rowPath,
+      cellPath: rowPath,
+      enabled
+    };
+    return /* @__PURE__ */ jsx(Cell, { ...props }, rowPath);
+  }
+};
+const getValidColumnProps = (scopedSchema) => {
+  if (isValidObjectSchema(scopedSchema)) {
+    return Object.keys(scopedSchema.properties).filter((prop) => scopedSchema.properties[prop].type !== "array");
+  }
+  return [""];
+};
+const EmptyTable = ({ numColumns, translations }) => /* @__PURE__ */ jsx(Table.Tr, { children: /* @__PURE__ */ jsx(NoBorderTableCell, { colSpan: numColumns, children: /* @__PURE__ */ jsx(Text, { align: "center", children: translations.noDataMessage }) }) });
+const TableHeaderCell = React.memo(function TableHeaderCell2(props) {
+  const { title, rowPath, propName, index } = props;
+  const [Component, _props] = useContextProps(
+    `Table.Header.${index}`,
+    `${rowPath}.Header.${propName}`,
+    { title },
+    props,
+    false
+  );
+  if (Component === void 0) {
+    return /* @__PURE__ */ jsx(Table.Th, { ..._props, title: void 0, children: _props == null ? void 0 : _props.title });
+  }
+  return /* @__PURE__ */ jsx(Component, { ..._props });
+});
+const ctxToNonEmptyCellProps = (ctx, ownProps) => {
+  const path = ownProps.rowPath + (isValidObjectSchema(ownProps.schema) ? "." + ownProps.propName : "");
+  const errors = formatErrorMessage(
+    union(errorsAt(path, ownProps.schema, (p) => p === path)(ctx.core.errors).map((error) => error.message))
+  );
+  return {
+    rowPath: ownProps.rowPath,
+    propName: ownProps.propName,
+    schema: ownProps.schema,
+    rootSchema: ctx.core.schema,
+    errors,
+    path,
+    enabled: ownProps.enabled,
+    cells: ownProps.cells || ctx.cells,
+    renderers: ownProps.renderers || ctx.renderers
+  };
+};
+const controlWithoutLabel = (scope) => ({
+  type: "Control",
+  scope,
+  label: false
+});
+const NonEmptyCellComponent = React.memo(function NonEmptyCellComponent2(props) {
+  const { path, propName, schema, rootSchema, errors, enabled, renderers, cells, isValid } = props;
+  const originalPath = useMemo(
+    () => path.replace(propName ? `.${propName}` : void 0, "").split(".").slice(0, -1).join("."),
+    [path, propName]
+  );
+  const componentProps = useProps("Table.Row", {}, {});
+  const contextProps = useProps(originalPath, {}, {});
+  const _contextProps = useProps(path, {}, {});
+  const { component, props: _props } = useMemo(
+    () => deepMerge(componentProps, contextProps, _contextProps),
+    [_contextProps, componentProps, contextProps]
+  );
+  const theme = useThemeCustomizer({ [path]: { component, props: _props } });
+  return /* @__PURE__ */ jsx(MantineThemeProvider, { theme, children: /* @__PURE__ */ jsxs(NoBorderTableCell, { children: [
+    schema.properties ? /* @__PURE__ */ jsx(
+      DispatchCell,
+      {
+        schema: Resolve.schema(schema, `#/properties/${encode(propName)}`, rootSchema),
+        uischema: controlWithoutLabel(`#/properties/${encode(propName)}`),
+        path,
+        enabled,
+        renderers,
+        cells
+      }
+    ) : /* @__PURE__ */ jsx(
+      DispatchCell,
+      {
+        schema,
+        uischema: controlWithoutLabel("#"),
+        path,
+        enabled,
+        renderers,
+        cells
+      }
+    ),
+    /* @__PURE__ */ jsx(Text, { size: "xs", children: !isValid ? errors : "" })
+  ] }) });
+});
+const NonEmptyCell = (ownProps) => {
+  const ctx = useJsonForms();
+  const emptyCellProps = ctxToNonEmptyCellProps(ctx, ownProps);
+  const isValid = isEmpty(emptyCellProps.errors);
+  return /* @__PURE__ */ jsx(NonEmptyCellComponent, { ...emptyCellProps, isValid });
+};
+const NonEmptyRowComponent = (props) => {
+  const {
+    childPath,
+    schema,
+    rowIndex,
+    openDeleteDialog,
+    moveUpCreator,
+    moveDownCreator,
+    enableUp,
+    enableDown,
+    showSortButtons,
+    enabled,
+    cells,
+    path,
+    translations,
+    disableRemove
+  } = props;
+  const defaultProps = { variant: "transparent", size: "sm", mt: "0.35rem" };
+  const iconProps = useProps("ActionIcon", defaultProps, {});
+  const moveUp = useMemo(() => moveUpCreator(path, rowIndex), [moveUpCreator, path, rowIndex]);
+  const moveDown = useMemo(() => moveDownCreator(path, rowIndex), [moveDownCreator, path, rowIndex]);
+  const [ComponentUp, _up_props] = useContextProps(
+    "Table.Row.Up",
+    `${childPath}.Row.Up`,
+    {
+      title: translations.up,
+      ["aria-label"]: translations.upAriaLabel,
+      onClick: moveUp,
+      disabled: !enableUp,
+      ...iconProps
+    },
+    props,
+    false
+  );
+  const [ComponentDown, _down_props] = useContextProps(
+    "Table.Row.Down",
+    `${childPath}.Row.Down`,
+    {
+      title: translations.down,
+      ["aria-label"]: translations.downAriaLabel,
+      onClick: moveDown,
+      disabled: !enableDown,
+      ...iconProps
+    },
+    props,
+    false
+  );
+  const [ComponentRemove, _remove_props] = useContextProps(
+    "Table.Row.Remove",
+    `${childPath}.Row.Remove`,
+    {
+      id: "tooltip-remove",
+      title: translations.removeTooltip,
+      ["aria-label"]: translations.removeAriaLabel,
+      onClick: () => openDeleteDialog(childPath, rowIndex),
+      ...iconProps
+    },
+    props,
+    false
+  );
+  const ActionIconUp = useMemo(
+    () => ComponentUp === void 0 ? /* @__PURE__ */ jsx(Grid.Col, { span: "content", children: /* @__PURE__ */ jsx(ActionIcon, { ..._up_props, children: /* @__PURE__ */ jsx(IconArrowUp, {}) }) }) : ComponentUp,
+    [ComponentUp, _up_props]
+  );
+  const ActionIconDown = useMemo(
+    () => ComponentDown === void 0 ? /* @__PURE__ */ jsx(Grid.Col, { span: "content", children: /* @__PURE__ */ jsx(ActionIcon, { ..._down_props, children: /* @__PURE__ */ jsx(IconArrowDown, {}) }) }) : ComponentDown,
+    [ComponentDown, _down_props]
+  );
+  const ActionIconRemove = useMemo(
+    () => ComponentRemove === void 0 ? /* @__PURE__ */ jsx(Grid.Col, { span: "content", children: /* @__PURE__ */ jsx(ActionIcon, { ..._remove_props, children: /* @__PURE__ */ jsx(IconTrash, {}) }) }) : ComponentRemove,
+    [ComponentRemove, _remove_props]
+  );
+  const SortButtons = useMemo(
+    () => /* @__PURE__ */ jsxs(Fragment, { children: [
+      ActionIconUp,
+      ActionIconDown
+    ] }),
+    [ActionIconDown, ActionIconUp]
+  );
+  const enableSort = useMemo(
+    () => !!showSortButtons && !!(ActionIconUp || ActionIconDown),
+    [showSortButtons, ActionIconUp, ActionIconDown]
+  );
+  const enableRemove = useMemo(() => !disableRemove && !!ActionIconRemove, [disableRemove, ActionIconRemove]);
+  const showCell = useMemo(() => enableSort || enableRemove, [enableSort, enableRemove]);
+  return /* @__PURE__ */ jsxs(Table.Tr, { children: [
+    generateCells(NonEmptyCell, schema, childPath, enabled, cells),
+    enabled && showCell ? /* @__PURE__ */ jsx(NoBorderTableCell, { style: showSortButtons ? styles.fixedCell : styles.fixedCellSmall, children: /* @__PURE__ */ jsxs(Grid, { justify: "flex-end", align: "center", children: [
+      enableSort && SortButtons,
+      enableRemove && ActionIconRemove
+    ] }) }) : null
+  ] }, childPath);
+};
+const NonEmptyRow = React.memo(NonEmptyRowComponent);
+const TableRows = (props) => {
+  const {
+    data,
+    path,
+    schema,
+    openDeleteDialog,
+    moveUp,
+    moveDown,
+    uischema,
+    config,
+    enabled,
+    cells,
+    translations,
+    disableRemove
+  } = props;
+  const isEmptyTable = data === 0;
+  if (isEmptyTable) {
+    return /* @__PURE__ */ jsx(EmptyTable, { numColumns: getValidColumnProps(schema).length + 1, translations });
+  }
+  const appliedUiSchemaOptions = merge({}, config, uischema.options);
+  return range(data).map((index) => {
+    const childPath = Paths.compose(path, `${index}`);
+    return /* @__PURE__ */ jsx(
+      NonEmptyRow,
+      {
+        childPath,
+        rowIndex: index,
+        schema,
+        openDeleteDialog,
+        moveUpCreator: moveUp,
+        moveDownCreator: moveDown,
+        enableUp: index !== 0,
+        enableDown: index !== data - 1,
+        showSortButtons: appliedUiSchemaOptions.showSortButtons || appliedUiSchemaOptions.showArrayTableSortButtons,
+        enabled,
+        cells,
+        path,
+        translations,
+        disableRemove
+      },
+      childPath
+    );
+  });
+};
+const MantineTableControl = memo(function MantineTableControl2(props) {
+  const {
+    label,
+    description,
+    path,
+    schema,
+    rootSchema,
+    uischema,
+    errors,
+    openDeleteDialog,
+    visible,
+    enabled,
+    cells,
+    translations,
+    disableAdd,
+    disableRemove,
+    config,
+    addItem
+  } = props;
+  const appliedUiSchemaOptions = merge({}, config, uischema.options);
+  const doDisableAdd = disableAdd || appliedUiSchemaOptions.disableAdd;
+  const doDisableRemove = disableRemove || appliedUiSchemaOptions.disableRemove;
+  const isObjectSchema = isValidObjectSchema(schema);
+  const headerCells = isObjectSchema ? generateCells(TableHeaderCell, schema, path, enabled, cells) : void 0;
+  const isEnabled = enabled && !doDisableAdd;
+  const [Component, _props] = useContextProps("Table", `${path}.Table`, {}, props, false);
+  if (!visible) {
+    return null;
+  }
+  if (Component === void 0) {
+    return /* @__PURE__ */ jsxs(Table, { ..._props, children: [
+      /* @__PURE__ */ jsxs(Table.Thead, { children: [
+        /* @__PURE__ */ jsx(
+          TableToolbar,
+          {
+            errors,
+            label,
+            description,
+            addItem,
+            numColumns: isObjectSchema ? headerCells.length : 1,
+            path,
+            uischema,
+            schema,
+            rootSchema,
+            enabled: isEnabled,
+            translations
+          }
+        ),
+        isObjectSchema && /* @__PURE__ */ jsxs(Table.Tr, { children: [
+          headerCells,
+          isEnabled ? /* @__PURE__ */ jsx(Table.Th, {}) : null
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Table.Tbody, { children: /* @__PURE__ */ jsx(
+        TableRows,
+        {
+          openDeleteDialog,
+          translations,
+          ...props,
+          disableRemove: doDisableRemove
+        }
+      ) })
+    ] });
+  }
+  return Component;
+});
+export {
+  MantineTableControl,
+  NonEmptyRow
+};

package/dist/jsonforms/esm/complex/MantineTableControl/NoBorderTableCell.mjs

@@ -0,0 +1,7 @@
+import { jsx } from "react/jsx-runtime";
+import { deepMerge } from "fastapi-rtk/utils";
+import { Table } from "@mantine/core";
+const NoBorderTableCell = ({ children, ...props }) => /* @__PURE__ */ jsx(Table.Td, { ...deepMerge({ style: { alignContent: "start" } }, props), children });
+export {
+  NoBorderTableCell
+};

package/dist/jsonforms/esm/complex/MantineTableControl/TableToolbar.mjs

@@ -0,0 +1,70 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { createDefaultValue } from "@jsonforms/core";
+import { useProps, Input, ActionIcon, Table, InputWrapper, Flex } from "@mantine/core";
+import { memo } from "react";
+import { useContextProps } from "../../hooks/useContextProps.mjs";
+import { NoBorderTableCell } from "./NoBorderTableCell.mjs";
+import { ValidationIcon } from "./ValidationIcon.mjs";
+import IconPlus from "../../../../external/esm/@tabler_icons-react@3.18.0_react@18.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconPlus.mjs";
+const fixedCellSmall = {
+  paddingLeft: 0,
+  paddingRight: 0
+};
+const TableToolbar = memo(function TableToolbar2(props) {
+  const { numColumns, errors, label, description, path, addItem, schema, enabled, translations, rootSchema } = props;
+  const defaultProps = { variant: "transparent", size: "sm", mt: "0.35rem" };
+  const iconProps = useProps("ActionIcon", defaultProps, {});
+  const [ComponentLabel, _label_props] = useContextProps(
+    "Table.Header.Label",
+    `${path}.Header.Label`,
+    { value: label },
+    props,
+    false
+  );
+  const [ComponentDescription, _description_props] = useContextProps(
+    "Table.Header.Description",
+    `${path}.Header.Description`,
+    { value: description },
+    props,
+    false
+  );
+  const [ComponentValidation, _validation_props] = useContextProps(
+    "Table.Header.Validation",
+    `${path}.Header.Validation`,
+    {
+      id: "tooltip-validation",
+      error: errors
+    },
+    props,
+    false
+  );
+  const [ComponentAdd, _add_props] = useContextProps(
+    "Table.Header.Add",
+    `${path}.Header.Add`,
+    {
+      id: "tooltip-add",
+      title: translations.addTooltip,
+      onClick: addItem(path, createDefaultValue(schema, rootSchema)),
+      ...iconProps
+    },
+    props,
+    false
+  );
+  const TextLabel = ComponentLabel === void 0 ? (_label_props == null ? void 0 : _label_props.value) ? /* @__PURE__ */ jsx(Input.Label, { children: _label_props == null ? void 0 : _label_props.value }) : null : ComponentLabel;
+  const TextDescription = ComponentDescription === void 0 ? (_description_props == null ? void 0 : _description_props.value) ? /* @__PURE__ */ jsx(Input.Description, { children: _description_props == null ? void 0 : _description_props.value }) : null : ComponentDescription;
+  const IconValidation = ComponentValidation === void 0 ? /* @__PURE__ */ jsx(ValidationIcon, { ..._validation_props }) : ComponentValidation;
+  const ActionIconAdd = ComponentAdd === void 0 ? /* @__PURE__ */ jsx(ActionIcon, { ..._add_props, children: /* @__PURE__ */ jsx(IconPlus, {}) }) : ComponentAdd;
+  return /* @__PURE__ */ jsxs(Table.Tr, { children: [
+    /* @__PURE__ */ jsx(NoBorderTableCell, { colSpan: numColumns, children: /* @__PURE__ */ jsxs(InputWrapper, { children: [
+      /* @__PURE__ */ jsxs(Flex, { justify: "flex-start", align: "center", gap: "sm", children: [
+        TextLabel,
+        IconValidation
+      ] }),
+      TextDescription
+    ] }) }),
+    enabled && ActionIconAdd && /* @__PURE__ */ jsx(NoBorderTableCell, { align: "right", style: fixedCellSmall, children: ActionIconAdd })
+  ] });
+});
+export {
+  TableToolbar
+};

package/dist/jsonforms/esm/complex/MantineTableControl/ValidationIcon.mjs

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import { Tooltip, Indicator } from "@mantine/core";
+import IconExclamationCircle from "../../../../external/esm/@tabler_icons-react@3.18.0_react@18.3.1/node_modules/@tabler/icons-react/dist/esm/icons/IconExclamationCircle.mjs";
+const ValidationIcon = ({ id, error }) => {
+  const errorMessageList = (error == null ? void 0 : error.split("\n")) || [];
+  return /* @__PURE__ */ jsx(Tooltip, { id, label: `${errorMessageList.length} error(s)`, position: "right", children: /* @__PURE__ */ jsx(
+    Indicator,
+    {
+      size: "0.85rem",
+      label: errorMessageList.length,
+      disabled: !error,
+      style: { visibility: error ? "visible" : "hidden" },
+      children: /* @__PURE__ */ jsx(IconExclamationCircle, {})
+    }
+  ) });
+};
+export {
+  ValidationIcon
+};

package/dist/jsonforms/esm/controls/MantineBooleanControl.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isBooleanControl } from "@jsonforms/core";
+import { withJsonFormsControlProps } from "@jsonforms/react";
+import { MantineBooleanInput } from "../MantineInputs/MantineBooleanInput.mjs";
+const mantineBooleanControlTester = rankWith(1, isBooleanControl);
+const MantineBooleanControl = withJsonFormsControlProps((props) => /* @__PURE__ */ jsx(MantineBooleanInput, { ...props }));
+export {
+  MantineBooleanControl,
+  mantineBooleanControlTester
+};

package/dist/jsonforms/esm/controls/MantineDateControl.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isDateControl } from "@jsonforms/core";
+import { withJsonFormsControlProps } from "@jsonforms/react";
+import { MantineDateInput } from "../MantineInputs/MantineDateInput.mjs";
+const mantineDateControlTester = rankWith(1, isDateControl);
+const MantineDateControl = withJsonFormsControlProps((props) => /* @__PURE__ */ jsx(MantineDateInput, { ...props }));
+export {
+  MantineDateControl,
+  mantineDateControlTester
+};

package/dist/jsonforms/esm/controls/MantineDateTimeControl.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isDateTimeControl } from "@jsonforms/core";
+import { withJsonFormsControlProps } from "@jsonforms/react";
+import { MantineDateTimeInput } from "../MantineInputs/MantineDateTimeInput.mjs";
+const mantineDateTimeControlTester = rankWith(1, isDateTimeControl);
+const MantineDateTimeControl = withJsonFormsControlProps((props) => /* @__PURE__ */ jsx(MantineDateTimeInput, { ...props }));
+export {
+  MantineDateTimeControl,
+  mantineDateTimeControlTester
+};

package/dist/jsonforms/esm/controls/MantineEnumControl.mjs

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import { rankWith, isEnumControl } from "@jsonforms/core";
+import { withJsonFormsEnumProps, withTranslateProps } from "@jsonforms/react";
+import { MantineEnumInput } from "../MantineInputs/MantineEnumInput.mjs";
+const mantineEnumControlTester = rankWith(2, isEnumControl);
+const MantineEnumControl = withJsonFormsEnumProps(
+  withTranslateProps((props) => /* @__PURE__ */ jsx(MantineEnumInput, { ...props })),
+  false
+);
+export {
+  MantineEnumControl,
+  mantineEnumControlTester
+};