@ghentcdh/json-forms-vue 0.8.6 → 1.0.1

package/index.js

@@ -1,1130 +1,398 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const toolsVue = require("@ghentcdh/tools-vue");
-const ui = require("@ghentcdh/ui");
-const core = require("@jsonforms/core");
 const vue = require("vue");
-const vue$1 = require("@jsonforms/vue");
-const axios = require("axios");
-const vueVanilla = require("@jsonforms/vue-vanilla");
 const lodashEs = require("lodash-es");
-const testers = require("@jsonforms/core/src/testers/testers");
 const jsonFormsCore = require("@ghentcdh/json-forms-core");
-const core$1 = require("@vueuse/core");
+const ui = require("@ghentcdh/ui");
+const core = require("@vueuse/core");
 const vueRouter = require("vue-router");
-class FormStore {
-  constructor(uri) {
-    this.uri = uri;
-  }
-  async delete(data) {
-    return toolsVue.useApi().delete(`${this.uri}/${data.id}`).then(() => {
-      ui.NotificationService.success("Data deleted");
-    }).catch((error2) => {
-      console.error(error2);
-      ui.NotificationService.error("Error deleting data");
-    });
-  }
-  async save(id, data) {
-    if (!this.uri) return;
-    const promise2 = id ? toolsVue.useApi().patch(`${this.uri}/${id}`, data) : toolsVue.useApi().post(this.uri, data);
-    return promise2.then(() => {
-      ui.NotificationService.success("Data saved");
-    }).catch((error2) => {
-      console.error(error2);
-      ui.NotificationService.error("Error saving data");
-    });
-  }
-}
-const FormComponentProperties = {
-  /** Unique id applied to the `<form>` element and used as `<json-forms>` key. */
-  id: { type: String, required: true },
-  name: { type: String, default: "form" },
+const toolsVue = require("@ghentcdh/tools-vue");
+const veeValidate = require("vee-validate");
+const core$1 = require("@jsonforms/core");
+const testers = require("@jsonforms/core/src/testers/testers");
+const axios = require("axios");
+const FormModalProperties = {
+  /** Title displayed in the modal header. */
+  modalTitle: { type: String, required: true },
+  /** Label for the save button. */
+  saveLabel: { type: String, default: "save" },
+  /** Label for the cancel button. */
+  cancelLabel: { type: String, default: "cancel" },
   /** JSON schema describing the shape of the form data. */
   schema: { type: Object, required: true },
   /** UI schema describing the layout and controls. */
   uiSchema: { type: Object, required: true },
-  /** Extra renderer entries merged in front of the built-in tailwind renderers. */
-  renderers: {
-    type: Array,
-    default: void 0
+  /** Modal width (`'xs'`, `'sm'`, `'md'`, `'lg'`, `'xl'`). */
+  modalSize: { type: String, default: "md" },
+  /** Callback invoked when the modal closes (with result or `null` on cancel). */
+  onClose: {
+    type: Function,
+    required: true
   },
-  /** Disables all controls inside the form. */
-  disabled: { type: Boolean, default: false },
-  formData: { type: Object, default: () => ({}) }
-};
-const FormComponentEmits = [
-  /** Emitted whenever validity changes (`true` = no errors). */
-  "valid",
-  /** Emitted on every change with the latest form data. */
-  "change",
-  /** Emitted when the native form submit fires. Payload: `SubmitFormEvent`. */
-  "submit",
-  /** Emitted with the raw Ajv validation errors array. */
-  "errors",
-  /** Generic event channel for custom renderer dispatches (`FormEventPayload`). */
-  "events"
-];
-const FormWithActionsProperties = {
-  /** Unique identifier; the inner form receives `form_${id}` as its id. */
-  id: { type: String, required: true },
-  /** Title shown when creating a new record (`formData.id` is falsy). */
-  createTitle: { type: String, required: true },
-  /** Title shown when editing an existing record. Falls back to `createTitle`. */
-  updateTitle: { type: String },
-  /** JSON schema describing the shape of the form data. */
-  schema: { type: Object },
-  /** UI schema describing the layout and controls. */
-  uiSchema: { type: Object },
-  /** When provided, the component submits the form to this URI via `FormStore`. */
-  uri: { type: String },
-  /** When true, the form content scrolls and the action bar stays pinned. */
-  scrollable: { type: Boolean, default: false },
-  /** When true, the component takes the full height of its parent. */
-  fullHeight: { type: Boolean, default: false }
+  /** Callback for form events dispatched by custom renderers. */
+  onEvents: {
+    type: Function
+  },
+  /** Initial form data to populate the form with. */
+  data: { type: Object, required: true },
+  /** When validation errors are shown. */
+  errorMode: {
+    type: String,
+    default: "onBlur"
+  }
 };
-const FormWithActionsEmits = [
-  /** v-model binding. */
-  "update:modelValue",
-  /** Emitted after a successful backend save (only when `uri` is defined). */
-  "success",
-  /** Emitted with form data when saving without a `uri`. */
-  "submit",
-  /** Emitted whenever the form validity changes. */
-  "valid",
-  /** Forwards custom renderer events (`FormEventPayload`). */
+const FormModalEmits = [
+  /** Emitted when the modal is closed (submit or cancel). */
+  "closeModal",
+  /** Emitted when a custom renderer dispatches a form event. */
   "events",
+  /** Emitted when validation errors change. */
   "errors",
-  /** Emitted when the cancel button is clicked (only visible when editing). */
-  "cancel"
-];
-const FormWithTableProperties = {
-  /** Unique identifier used to generate the table form id (`form_table_${id}`). */
-  id: { type: String, required: true },
-  /** Heading displayed above the table. */
-  tableTitle: { type: String, required: true },
-  /** Title shown in the create modal. */
-  createTitle: { type: String, required: true },
-  /** Title shown in the edit modal. Falls back to `createTitle`. */
-  updateTitle: { type: String },
-  /** Overrides `uri` as the data source for the table. */
-  dataUri: { type: String },
-  /** Custom action buttons rendered in each table row. */
-  tableActions: { type: Array },
-  /** Layout for the create/edit modal form. */
-  form: { type: Object },
-  /** Layout for the table columns. */
-  table: { type: Object },
-  /** Layout for the table filter controls. */
-  filter: { type: Object },
-  /** Base URI used by `FormStore` for CRUD operations and as the default table data source. */
-  uri: { type: String },
-  /** Default data used when opening the create modal. */
-  initialData: { type: Object, default: () => ({}) }
-};
-const FormWithTableEmits = [
-  /** Emitted when a table row is edited and a custom listener is bound. */
-  "editData",
-  /** Emitted after a record is successfully saved (created or updated). Payload: `{ id?: string, data: Data }`. */
-  "save",
-  /** Emitted after a record is successfully deleted. Payload: the deleted record. */
-  "delete",
-  /** Forwarded form events dispatched by custom renderers inside the modal (e.g. "create"). Payload: `FormEventPayload`. */
-  "events",
-  "custom:edit",
-  "custom:create"
+  /** Emitted when form validity changes. */
+  "valid"
 ];
-const createFormEvents = (dispatch) => ({
-  dispatch
-});
-const FORM_EVENTS_KEY = /* @__PURE__ */ Symbol("json-forms:events");
-const provideFormEvents = (dispatch) => {
-  const events = createFormEvents(dispatch);
-  vue.provide(FORM_EVENTS_KEY, events);
-  return events;
-};
-const useFormEvents = () => {
-  return vue.inject(
-    FORM_EVENTS_KEY,
-    createFormEvents(() => {
-    })
-  );
-};
-const useVanillaControlCustom = (input, adaptTarget = (v) => v.value) => {
-  const vanillaControl = vueVanilla.useVanillaControl(input, adaptTarget);
-  const isTouched = vue.ref(false);
-  const isFocused = vue.ref(false);
-  const onFocus = () => {
-    isFocused.value = true;
-  };
-  const onBlur = () => {
-    isTouched.value = true;
-    isFocused.value = false;
-  };
-  const controlWrapper = vue.computed(() => {
-    return {
-      ...vanillaControl.controlWrapper.value,
-      ...lodashEs.omit(vanillaControl.appliedOptions.value, "styles"),
-      ...lodashEs.pick(vanillaControl.appliedOptions.value.styles, ["width"]),
-      isFocused: isFocused.value,
-      isTouched: isTouched.value
-    };
-  });
-  return {
-    ...vanillaControl,
-    appliedOptions: vanillaControl.appliedOptions,
-    controlWrapper,
-    isFocused,
-    isTouched,
-    onFocus,
-    onBlur
-    // handleChange,
-  };
-};
-const _sfc_main$j = /* @__PURE__ */ vue.defineComponent({
-  __name: "AutocompleteControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const {
-      control,
-      handleChange: _handleChange,
-      appliedOptions,
-      onFocus,
-      onBlur,
-      controlWrapper
-    } = useVanillaControlCustom(vue$1.useJsonFormsControl(props));
-    const bindProperties = vue.computed(() => ({
-      ...controlWrapper.value,
-      ...appliedOptions.value,
-      enableCreate: !!appliedOptions.value.enableCreate
-    }));
-    const fetchOptions = vue.computed(() => {
-      const options = appliedOptions.value;
-      if (!options.uri) return null;
-      return (searchTerm, signal) => {
-        const fetch = options.skipAuth ? axios : toolsVue.useApi();
-        return fetch.get(`${options.uri}${searchTerm}`, { signal }).then((data) => data.data[options.dataField ?? "data"]);
-      };
-    });
-    const handleChange = (result) => {
-      const { path } = control.value;
-      _handleChange(path, result);
+const _hoisted_1$8 = { class: "" };
+const _hoisted_2$2 = { class: "flex gap-2 items-center mb-2" };
+const _hoisted_3$1 = { class: "flex gap-2" };
+const _sfc_main$h = /* @__PURE__ */ vue.defineComponent({
+  __name: "table-filter",
+  props: {
+    layout: {},
+    filters: {}
+  },
+  emits: ["changeFilters", "removeFilter"],
+  setup(__props, { emit: __emit }) {
+    const formData = vue.ref();
+    const properties = __props;
+    const emits = __emit;
+    vue.watch(
+      () => properties.filters,
+      () => {
+        formData.value = {};
+        properties.filters.forEach((filter) => {
+          formData.value[filter.key] = filter.value;
+        });
+      },
+      { immediate: true }
+    );
+    const onResetFilters = () => {
+      emits("changeFilters", {});
     };
-    const formEvents = useFormEvents();
-    const create = () => {
-      formEvents.dispatch({
-        event: "create",
-        type: control.value.path,
-        data: control.value.data,
-        onSuccess: (result) => {
-          handleChange(result);
-        }
-      });
+    const removeFilter = (filter) => {
+      formData.value[filter.key] = void 0;
+      emits("changeFilters", formData.value);
     };
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Autocomplete), vue.mergeProps(bindProperties.value, {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        "fetch-options": fetchOptions.value,
-        onChange: handleChange,
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur),
-        onCreate: _cache[0] || (_cache[0] = ($event) => create())
-      }), null, 16, ["model-value", "enabled", "fetch-options", "onFocus", "onBlur"]);
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$8, [
+        vue.createElementVNode("div", _hoisted_2$2, [
+          __props.filters.length ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
+            key: 0,
+            size: "xs",
+            outline: true,
+            onClick: onResetFilters
+          }, {
+            default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
+              vue.createTextVNode(" Reset all filters ", -1)
+            ])]),
+            _: 1
+          })) : vue.createCommentVNode("", true)
+        ]),
+        vue.createElementVNode("div", _hoisted_3$1, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.filters, (filter) => {
+            return vue.openBlock(), vue.createBlock(vue.unref(ui.BtnBadge), {
+              key: filter.key,
+              icon: vue.unref(ui.IconEnum).Close,
+              onClick: ($event) => removeFilter(filter)
+            }, {
+              default: vue.withCtx(() => [
+                vue.createTextVNode(vue.toDisplayString(filter.label) + ": " + vue.toDisplayString(filter.value), 1)
+              ]),
+              _: 2
+            }, 1032, ["icon", "onClick"]);
+          }), 128))
+        ])
+      ]);
     };
   }
 });
-const _sfc_main$i = /* @__PURE__ */ vue.defineComponent({
-  __name: "BooleanControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const {
-      control,
-      handleChange: _handleChange,
-      appliedOptions,
-      onFocus,
-      onBlur,
-      controlWrapper
-    } = useVanillaControlCustom(vue$1.useJsonFormsControl(props), (target) => {
-      if (!target.value) {
-        handleChange(false);
+const TableComponentProperties = {
+  id: { type: String, required: true },
+  uiSchema: { type: Object, required: true },
+  schema: { type: Object, required: true },
+  filterUiSchema: { type: Object },
+  filterSchema: { type: Object },
+  uri: { type: String, required: true },
+  reload: { type: Number },
+  actions: { type: Array }
+};
+const TableComponentEmits = ["delete", "edit"];
+class TableStore {
+  constructor() {
+    this.route = vueRouter.useRoute();
+    this.router = vueRouter.useRouter();
+    this.requestData = vue.ref(jsonFormsCore.RequestSchema.parse(this.route.query));
+    this._reload = vue.ref(Date.now());
+    this.loading = vue.ref(true);
+    this.uri = vue.ref("");
+    this.data = core.computedAsync(async () => {
+      this._reload.value;
+      if (!this.uri.value) return null;
+      this.loading.value = true;
+      if (this.requestData.value.page < 1) {
+        this.requestData.value.page = 1;
+      }
+      const response = await toolsVue.useApi().get(this.uri.value, {
+        params: this.requestData.value
+      }).catch((error2) => {
+        console.error(error2);
+        return { data: [], request: { totalPages: 1, page: 1 } };
+      }).finally(() => this.loading.value = false);
+      const data = response.data;
+      if (data.request.totalPages < data.request.page) {
+        this.updateRequest({ page: data.request.totalPages });
       }
-      return Boolean(target.value) ?? false;
+      return data;
+    });
+    this.pageData = vue.computed(() => {
+      const request = this.data.value?.request ?? {
+        count: 0,
+        pageSize: 1,
+        page: 1
+      };
+      return {
+        count: request.count,
+        pageSize: request.pageSize,
+        page: request.page
+      };
+    });
+    this.tableData = vue.computed(() => {
+      const d = this.data.value;
+      if (!d) return [];
+      if (this.loading.value) return [];
+      return d.data ?? [];
     });
-    const handleChange = (result) => {
-      const { path } = control.value;
-      _handleChange(path, result);
+    this.init = (url2) => {
+      this.uri.value = url2;
     };
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Checkbox), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        config: vue.unref(appliedOptions),
-        onChange: handleChange,
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "config", "onFocus", "onBlur"]);
+    this.updateRequest = (data) => {
+      this.requestData.value = { ...this.requestData.value, ...data };
+      this.router.replace({
+        query: {
+          ...this.route.query,
+          ...this.requestData.value
+        }
+      });
     };
-  }
-});
-const _sfc_main$h = /* @__PURE__ */ vue.defineComponent({
-  __name: "IntegerControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const { control, onChange, appliedOptions, onFocus, onBlur, controlWrapper } = useVanillaControlCustom(
-      vue$1.useJsonFormsControl(props),
-      (target) => target.value === "" ? void 0 : Number(target.value)
-    );
-    const steps = vue.computed(() => appliedOptions.value.steps ?? 1);
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.InputNumber), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        config: vue.unref(appliedOptions),
-        steps: steps.value,
-        onChange: vue.unref(onChange),
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "config", "steps", "onChange", "onFocus", "onBlur"]);
+    this.sort = (id) => {
+      const sortDir = this.requestData.value.sort === id && this.requestData.value.sortDir === "asc" ? "desc" : "asc";
+      this.updateRequest({ sort: id, sortDir });
     };
-  }
-});
-const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
-  __name: "MarkdownControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const {
-      control,
-      handleChange,
-      appliedOptions,
-      onFocus,
-      onBlur,
-      controlWrapper
-    } = useVanillaControlCustom(vue$1.useJsonFormsControl(props));
-    const changeValue = (value) => {
-      handleChange(control.value.path, value);
-    };
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Markdown), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        config: vue.unref(appliedOptions),
-        onChange: changeValue,
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "config", "onFocus", "onBlur"]);
-    };
-  }
-});
-const _sfc_main$f = /* @__PURE__ */ vue.defineComponent({
-  __name: "MultiSelectControlRender",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const {
-      control,
-      handleChange: _handleChange,
-      onFocus,
-      onBlur,
-      controlWrapper
-    } = useVanillaControlCustom(vue$1.useJsonFormsControl(props));
-    const handleChange = (result) => {
-      const { path } = control.value;
-      _handleChange(path, result);
-    };
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.MultiSelect), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        onChange: handleChange,
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "onFocus", "onBlur"]);
+    this.updateFilters = (filters) => {
+      const filter = [];
+      Object.entries(filters).forEach(([key, value]) => {
+        if (!value) return;
+        const operator = value?.operator || "contains";
+        filter.push(`${key}:${value}:${operator}`);
+      });
+      this.updateRequest({ filter });
     };
-  }
-});
-const _sfc_main$e = /* @__PURE__ */ vue.defineComponent({
-  __name: "NumberControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const { control, onChange, appliedOptions, onFocus, onBlur, controlWrapper } = useVanillaControlCustom(
-      vue$1.useJsonFormsControl(props),
-      (target) => target.value === "" ? void 0 : Number(target.value)
+    this.sorting = vue.computed(() => {
+      const requestData = this.requestData.value;
+      return {
+        sortColumn: requestData.sort,
+        sortDirection: requestData.sortDir ?? "asc"
+      };
+    });
+    this.filters = vue.computed(
+      () => jsonFormsCore.extractFilters(this.requestData.value.filter)
     );
-    const steps = vue.computed(() => appliedOptions.value.steps ?? 0.01);
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.InputNumber), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        config: vue.unref(appliedOptions),
-        steps: steps.value,
-        onChange: vue.unref(onChange),
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "config", "steps", "onChange", "onFocus", "onBlur"]);
-    };
   }
-});
-const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
-  __name: "SelectControlRender",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const {
-      control,
-      handleChange: _handleChange,
-      appliedOptions,
-      onFocus,
-      onBlur,
-      controlWrapper
-    } = useVanillaControlCustom(vue$1.useJsonFormsControl(props));
-    const handleChange = (result) => {
-      const { path } = control.value;
-      _handleChange(path, result);
-    };
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.SelectComponent), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        options: vue.unref(appliedOptions)?.options,
-        onChange: handleChange,
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "options", "onFocus", "onBlur"]);
-    };
+  get httpRequest() {
+    return toolsVue.useApi();
   }
-});
-const _sfc_main$c = /* @__PURE__ */ vue.defineComponent({
-  __name: "StringControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const {
-      control,
-      onChange,
-      appliedOptions,
-      onFocus,
-      onBlur,
-      controlWrapper,
-      styles
-    } = useVanillaControlCustom(vue$1.useJsonFormsControl(props));
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Input), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        config: vue.unref(appliedOptions),
-        styles: vue.unref(styles),
-        onChange: vue.unref(onChange),
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "config", "styles", "onChange", "onFocus", "onBlur"]);
-    };
+  reload() {
+    this._reload.value = Date.now();
   }
-});
-const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
-  __name: "TextAreaControlRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const { control, onChange, appliedOptions, onFocus, onBlur, controlWrapper } = useVanillaControlCustom(vue$1.useJsonFormsControl(props));
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Textarea), vue.mergeProps(vue.unref(controlWrapper), {
-        "model-value": vue.unref(control).data,
-        enabled: vue.unref(control).enabled,
-        config: vue.unref(appliedOptions),
-        onChange: vue.unref(onChange),
-        onFocus: vue.unref(onFocus),
-        onBlur: vue.unref(onBlur)
-      }), null, 16, ["model-value", "enabled", "config", "onChange", "onFocus", "onBlur"]);
-    };
+  updatePage(page) {
+    this.updateRequest({ page });
   }
-});
-const isAutoCompleteControl = testers.and(
-  // uiTypeIs('Control'),
-  testers.optionIs("format", jsonFormsCore.ControlType.autocomplete)
-);
-const isTextAreaControl = testers.and(
-  core.uiTypeIs("Control"),
-  testers.optionIs("format", jsonFormsCore.ControlType.textArea)
-);
-const isStringFormat = testers.and(
-  core.uiTypeIs("Control"),
-  testers.or(testers.optionIs("format", jsonFormsCore.ControlType.string), testers.schemaTypeIs("string"))
-);
-const isMarkdownControl = testers.and(
-  core.uiTypeIs("Control"),
-  testers.optionIs("format", jsonFormsCore.ControlType.markdown)
-);
-const isArrayRenderer = testers.and(
-  testers.schemaTypeIs("array")
-  // optionIs('format', ControlType.array),
-);
-const isCustomControl = (customType) => {
-  return testers.and(
-    testers.optionIs("format", jsonFormsCore.ControlType.custom),
-    testers.optionIs("type", customType)
-  );
+}
+const tableCache = /* @__PURE__ */ new Map();
+const useTableStore = (name) => {
+  const tableStore = tableCache.get(name);
+  if (tableStore) {
+    return tableStore;
+  }
+  const newTableStore = new TableStore();
+  tableCache.set(name, newTableStore);
+  return newTableStore;
 };
-const isMultiselectControl = testers.and(
-  core.uiTypeIs("Control"),
-  testers.optionIs("format", jsonFormsCore.ControlType.mutliSelect)
-);
-const isSelectControl = testers.and(
-  core.uiTypeIs("Control"),
-  testers.optionIs("format", jsonFormsCore.ControlType.select)
-);
-const isBooleanControl = testers.or(
-  testers.isBooleanControl,
-  testers.and(core.uiTypeIs("Control"), testers.optionIs("format", jsonFormsCore.ControlType.boolean))
-);
-const controlRenderers = [
-  // First custom renderers on format
-  {
-    tester: core.rankWith(10, isMarkdownControl),
-    renderer: _sfc_main$g
-  },
-  {
-    tester: core.rankWith(10, isAutoCompleteControl),
-    renderer: _sfc_main$j
-  },
-  {
-    tester: core.rankWith(10, isTextAreaControl),
-    renderer: _sfc_main$b
-  },
-  // Renderers based on type if no format is provided
-  { tester: core.rankWith(10, isStringFormat), renderer: _sfc_main$c },
-  { tester: core.rankWith(10, isSelectControl), renderer: _sfc_main$d },
-  {
-    tester: core.rankWith(10, isMultiselectControl),
-    renderer: _sfc_main$f
-  },
-  { tester: core.rankWith(10, core.isNumberControl), renderer: _sfc_main$e },
-  {
-    tester: core.rankWith(10, core.isIntegerControl),
-    renderer: _sfc_main$h
-  },
-  { tester: core.rankWith(10, isBooleanControl), renderer: _sfc_main$i }
-];
-const _hoisted_1$9 = ["title"];
-const _hoisted_2$2 = { key: 0 };
-const _hoisted_3$1 = {
-  key: 1,
-  class: "list-row"
+const _hoisted_1$7 = {
+  key: 0,
+  class: "mb-2"
 };
-const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
-  __name: "ArrayRenderer",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const vanillaArrayControl = vueVanilla.useVanillaArrayControl(
-      vue$1.useJsonFormsArrayControl(props)
+const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
+  __name: "table.component",
+  props: TableComponentProperties,
+  emits: TableComponentEmits,
+  setup(__props, { emit: __emit }) {
+    const properties = __props;
+    const emit = __emit;
+    vue.watch(
+      () => properties.reload,
+      () => {
+        store.reload();
+      }
     );
-    const { styles, childUiSchema, control, appliedOptions } = vanillaArrayControl;
-    if (!control.value.data || control.value.data.length < 1) {
-      vanillaArrayControl.addItem(
-        control.value.path,
-        core.createDefaultValue(control.value.schema, control.value.rootSchema)
-      )();
-    }
-    const noData = vue.computed(
-      () => !control.value.data || control.value.data.length === 0
+    let store = useTableStore(properties.id);
+    vue.watch(
+      () => properties.uri,
+      () => {
+        store.init(properties.uri);
+      },
+      { immediate: true }
     );
-    const showDelete = vue.computed(() => control.value.data?.length > 1);
-    const deleteButtonClick = (index) => {
-      vanillaArrayControl.removeItems(control.value.path, [index])();
+    const edit = (data) => {
+      emit("edit", data);
+    };
+    const deleteFn = (data) => {
+      emit("delete", data);
+    };
+    const components = {
+      TextCell: ui.TextCell,
+      BooleanCell: ui.BooleanCell
+    };
+    const displayColumns = vue.computed(() => {
+      return properties.uiSchema.elements.map((e) => {
+        const element = e;
+        const def = jsonFormsCore.findColumnDef(element, properties.schema);
+        const type = lodashEs.isArray(def.type) ? def.type[0] : def.type;
+        let component;
+        if (element.options?.format && element.options.format in components) {
+          component = components[element.options.format];
+        } else {
+          component = components[element.type];
+        }
+        if (!component) console.warn("No component found for type", element.type);
+        return {
+          ...def,
+          type,
+          component
+        };
+      });
+    });
+    const onChangeFilters = (filters) => {
+      store.updateFilters(filters);
+    };
+    const onUpdatePage = (page) => {
+      store.updatePage(page);
     };
-    const addButtonClick = () => {
-      vanillaArrayControl.addItem(
-        control.value.path,
-        core.createDefaultValue(control.value.schema, control.value.rootSchema)
-      )();
+    const onSort = (id) => {
+      store.sort(id);
     };
-    const showActions = vue.computed(() => {
-      return !appliedOptions.value.hideActions;
+    const sort = vue.computed(() => {
+      return store.sorting.value ?? { orderBy: "", ascending: 1 };
     });
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", {
-        title: vue.unref(control).label
-      }, [
-        vue.createElementVNode("div", {
-          class: vue.normalizeClass([
-            "flex gap-2",
-            vue.unref(appliedOptions)?.layout === "row" ? "flex-row items-center" : "flex-col"
-          ])
-        }, [
-          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(control).data, (element, index) => {
-            return vue.openBlock(), vue.createElementBlock("div", {
-              key: `${vue.unref(control).path}-${index}`,
-              class: "flex-1"
-            }, [
-              vue.createElementVNode("div", {
-                class: vue.normalizeClass([
-                  "flex gap-2",
-                  vue.unref(appliedOptions)?.layout === "row" ? "flex-col" : "flex-row items-center"
-                ])
-              }, [
-                vue.createElementVNode("div", null, [
-                  vue.createVNode(vue.unref(vue$1.DispatchRenderer), {
-                    schema: vue.unref(control).schema,
-                    uischema: vue.unref(childUiSchema),
-                    path: vue.unref(core.composePaths)(vue.unref(control).path, `${index}`),
-                    enabled: vue.unref(control).enabled,
-                    renderers: vue.unref(control).renderers,
-                    cells: vue.unref(control).cells
-                  }, null, 8, ["schema", "uischema", "path", "enabled", "renderers", "cells"])
-                ]),
-                showActions.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$2, [
-                  showDelete.value ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
-                    key: 0,
-                    icon: vue.unref(ui.IconEnum).Delete,
-                    outline: true,
-                    onClick: ($event) => deleteButtonClick(index)
-                  }, null, 8, ["icon", "onClick"])) : vue.createCommentVNode("", true)
-                ])) : vue.createCommentVNode("", true)
-              ], 2)
-            ]);
-          }), 128)),
-          noData.value ? (vue.openBlock(), vue.createElementBlock("div", {
-            key: 0,
-            class: vue.normalizeClass(["list-row", vue.unref(styles).arrayList.noData])
-          }, " No data ", 2)) : vue.createCommentVNode("", true),
-          showActions.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3$1, [
-            vue.createVNode(vue.unref(ui.Btn), {
-              icon: vue.unref(ui.IconEnum).Plus,
-              outline: true,
-              onClick: addButtonClick
-            }, {
-              default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
-                vue.createTextVNode(" Add ", -1)
-              ])]),
-              _: 1
-            }, 8, ["icon"])
-          ])) : vue.createCommentVNode("", true)
-        ], 2)
-      ], 8, _hoisted_1$9);
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        _ctx.filterUiSchema && _ctx.filterSchema ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$7, [
+          vue.createVNode(_sfc_main$h, {
+            layout: { uiSchema: _ctx.filterUiSchema, schema: _ctx.filterSchema },
+            filters: vue.unref(store).filters.value,
+            onChangeFilters
+          }, null, 8, ["layout", "filters"])
+        ])) : vue.createCommentVNode("", true),
+        vue.createElementVNode("div", null, [
+          vue.createVNode(vue.unref(ui.Table), {
+            "display-columns": displayColumns.value,
+            sort: sort.value,
+            page: vue.unref(store).pageData.value,
+            loading: vue.unref(store).loading.value,
+            data: vue.unref(store).tableData.value,
+            actions: _ctx.actions,
+            onUpdatePage,
+            onDelete: deleteFn,
+            onEdit: edit,
+            onSort
+          }, null, 8, ["display-columns", "sort", "page", "loading", "data", "actions"])
+        ])
+      ]);
     };
   }
 });
-const arrayRenderers = [
-  {
-    tester: core.rankWith(12, isArrayRenderer),
-    renderer: _sfc_main$a
-  }
-];
-const _hoisted_1$8 = { class: "flex flex-col gap-4" };
-const _sfc_main$9 = /* @__PURE__ */ vue.defineComponent({
-  __name: "CollapseLayout",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const jsonLayout = vue$1.useJsonFormsLayout(props);
-    const { layout, renderers, cells } = jsonLayout;
-    const title = vue.computed(() => {
-      const { titleKey, title: title2 } = layout?.value.uischema?.options ?? {};
-      if (title2) return title2;
-      if (titleKey) return layout?.value.data[titleKey];
-      return layout?.value.uischema?.options?.titleKey;
-    });
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Collapse), { title: title.value }, {
-        default: vue.withCtx(() => [
-          vue.createElementVNode("div", _hoisted_1$8, [
-            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(layout).uischema.elements, (element, index) => {
-              return vue.openBlock(), vue.createBlock(vue.unref(vue$1.DispatchRenderer), {
-                key: index,
-                schema: vue.unref(layout).schema,
-                uischema: element,
-                path: vue.unref(layout).path,
-                renderers: vue.unref(renderers),
-                cells: vue.unref(cells)
-              }, null, 8, ["schema", "uischema", "path", "renderers", "cells"]);
-            }), 128))
-          ])
-        ]),
-        _: 1
-      }, 8, ["title"]);
-    };
-  }
-});
-const _hoisted_1$7 = {
-  class: "grid gap-4 items-center",
-  style: { "grid-template-columns": "repeat(12, 1fr)" }
-};
-const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
-  __name: "GridLayout",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const { layout, renderers, cells } = vue$1.useJsonFormsLayout(props);
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$7, [
-        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(layout).uischema.elements, (element, index) => {
-          return vue.openBlock(), vue.createElementBlock("div", {
-            key: index,
-            style: vue.normalizeStyle({
-              "grid-column": `span ${element.options?.colspan ?? 12}`
-            })
-          }, [
-            vue.createVNode(vue.unref(vue$1.DispatchRenderer), {
-              schema: vue.unref(layout).schema,
-              uischema: element,
-              path: vue.unref(layout).path,
-              renderers: vue.unref(renderers),
-              cells: vue.unref(cells)
-            }, null, 8, ["schema", "uischema", "path", "renderers", "cells"])
-          ], 4);
-        }), 128))
-      ]);
-    };
-  }
-});
-const _hoisted_1$6 = { class: "flex flex-row gap-4 items-center" };
-const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
-  __name: "HorizontalLayout",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const { layout, renderers, cells } = vue$1.useJsonFormsLayout(props);
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$6, [
-        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(layout).uischema.elements, (element, index) => {
-          return vue.openBlock(), vue.createBlock(vue.unref(vue$1.DispatchRenderer), {
-            key: index,
-            schema: vue.unref(layout).schema,
-            uischema: element,
-            path: vue.unref(layout).path,
-            renderers: vue.unref(renderers),
-            cells: vue.unref(cells)
-          }, null, 8, ["schema", "uischema", "path", "renderers", "cells"]);
-        }), 128))
-      ]);
-    };
-  }
-});
-const _hoisted_1$5 = { class: "flex flex-col gap-4" };
-const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
-  __name: "VerticalLayout",
-  props: { ...vue$1.rendererProps() },
-  setup(__props) {
-    const props = __props;
-    const { layout, renderers, cells } = vue$1.useJsonFormsLayout(props);
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$5, [
-        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(layout).uischema.elements, (element, index) => {
-          return vue.openBlock(), vue.createBlock(vue.unref(vue$1.DispatchRenderer), {
-            key: index,
-            schema: vue.unref(layout).schema,
-            uischema: element,
-            path: vue.unref(layout).path,
-            renderers: vue.unref(renderers),
-            cells: vue.unref(cells)
-          }, null, 8, ["schema", "uischema", "path", "renderers", "cells"]);
-        }), 128))
-      ]);
-    };
-  }
-});
-const layoutRenderers = [
-  {
-    tester: core.rankWith(10, core.uiTypeIs(jsonFormsCore.LayoutTypes.VerticalLayout)),
-    renderer: _sfc_main$6
-  },
-  {
-    tester: core.rankWith(10, core.uiTypeIs(jsonFormsCore.LayoutTypes.HorizontalLayout)),
-    renderer: _sfc_main$7
-  },
-  {
-    tester: core.rankWith(10, core.uiTypeIs(jsonFormsCore.LayoutTypes.CollapseLayout)),
-    renderer: _sfc_main$9
-  },
-  {
-    tester: core.rankWith(10, core.uiTypeIs(jsonFormsCore.LayoutTypes.GridLayout)),
-    renderer: _sfc_main$8
-  }
-];
-const _hoisted_1$4 = { class: "" };
-const _hoisted_2$1 = { class: "flex gap-2 items-center mb-2" };
-const _hoisted_3 = { class: "flex gap-2" };
-const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
-  __name: "table-filter",
-  props: {
-    layout: {},
-    filters: {}
-  },
-  emits: ["changeFilters", "removeFilter"],
-  setup(__props, { emit: __emit }) {
-    const formData = vue.ref();
-    const properties = __props;
-    const emits = __emit;
-    vue.watch(
-      () => properties.filters,
-      () => {
-        formData.value = {};
-        properties.filters.forEach((filter) => {
-          formData.value[filter.key] = filter.value;
-        });
-      },
-      { immediate: true }
-    );
-    const onResetFilters = () => {
-      emits("changeFilters", {});
-    };
-    const removeFilter = (filter) => {
-      formData.value[filter.key] = void 0;
-      emits("changeFilters", formData.value);
-    };
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$4, [
-        vue.createElementVNode("div", _hoisted_2$1, [
-          __props.filters.length ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
-            key: 0,
-            size: "xs",
-            outline: true,
-            onClick: onResetFilters
-          }, {
-            default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
-              vue.createTextVNode(" Reset all filters ", -1)
-            ])]),
-            _: 1
-          })) : vue.createCommentVNode("", true)
-        ]),
-        vue.createElementVNode("div", _hoisted_3, [
-          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.filters, (filter) => {
-            return vue.openBlock(), vue.createBlock(vue.unref(ui.BtnBadge), {
-              key: filter.key,
-              icon: vue.unref(ui.IconEnum).Close,
-              onClick: ($event) => removeFilter(filter)
-            }, {
-              default: vue.withCtx(() => [
-                vue.createTextVNode(vue.toDisplayString(filter.label) + ": " + vue.toDisplayString(filter.value), 1)
-              ]),
-              _: 2
-            }, 1032, ["icon", "onClick"]);
-          }), 128))
-        ])
-      ]);
-    };
-  }
-});
-const TableComponentProperties = {
-  id: { type: String, required: true },
-  uiSchema: { type: Object, required: true },
-  schema: { type: Object, required: true },
-  filterUiSchema: { type: Object },
-  filterSchema: { type: Object },
-  uri: { type: String, required: true },
-  reload: { type: Number },
-  actions: { type: Array }
-};
-const TableComponentEmits = ["delete", "edit"];
-class TableStore {
-  constructor() {
-    this.route = vueRouter.useRoute();
-    this.router = vueRouter.useRouter();
-    this.requestData = vue.ref(jsonFormsCore.RequestSchema.parse(this.route.query));
-    this._reload = vue.ref(Date.now());
-    this.loading = vue.ref(true);
-    this.uri = vue.ref("");
-    this.data = core$1.computedAsync(async () => {
-      this._reload.value;
-      if (!this.uri.value) return null;
-      this.loading.value = true;
-      if (this.requestData.value.page < 1) {
-        this.requestData.value.page = 1;
-      }
-      const response = await toolsVue.useApi().get(this.uri.value, {
-        params: this.requestData.value
-      }).catch((error2) => {
-        console.error(error2);
-        return { data: [], request: { totalPages: 1, page: 1 } };
-      }).finally(() => this.loading.value = false);
-      const data = response.data;
-      if (data.request.totalPages < data.request.page) {
-        this.updateRequest({ page: data.request.totalPages });
-      }
-      return data;
-    });
-    this.pageData = vue.computed(() => {
-      const request = this.data.value?.request ?? {
-        count: 0,
-        pageSize: 1,
-        page: 1
-      };
-      return {
-        count: request.count,
-        pageSize: request.pageSize,
-        page: request.page
-      };
-    });
-    this.tableData = vue.computed(() => {
-      const d = this.data.value;
-      if (!d) return [];
-      if (this.loading.value) return [];
-      return d.data ?? [];
+const createRepository = (formSchemaModel, httpRequest, options = {}) => {
+  const notificationEntity = options.notification?.entityType || "entity";
+  const notificationStore = options.notification?.notification ?? null;
+  const getDataUri = (...suffix) => {
+    return [formSchemaModel.uri, ...suffix].join("/");
+  };
+  const handleSuccess = (message) => {
+    notificationStore?.success(message);
+  };
+  const handleError = (error2, message) => {
+    console.error(error2);
+    notificationStore?.error(message);
+    throw new Error(error2);
+  };
+  const create = (object2, options2) => {
+    return httpRequest.post(getDataUri(), object2, options2).then((response) => {
+      handleSuccess(`Created ${notificationEntity}`);
+      return response.data;
+    }).catch((response) => {
+      handleError(response, `Failed to create ${notificationEntity}`);
     });
-    this.init = (url2) => {
-      this.uri.value = url2;
-    };
-    this.updateRequest = (data) => {
-      this.requestData.value = { ...this.requestData.value, ...data };
-      this.router.replace({
-        query: {
-          ...this.route.query,
-          ...this.requestData.value
-        }
-      });
-    };
-    this.sort = (id) => {
-      const sortDir = this.requestData.value.sort === id && this.requestData.value.sortDir === "asc" ? "desc" : "asc";
-      this.updateRequest({ sort: id, sortDir });
-    };
-    this.updateFilters = (filters) => {
-      const filter = [];
-      Object.entries(filters).forEach(([key, value]) => {
-        if (!value) return;
-        const operator = value?.operator || "contains";
-        filter.push(`${key}:${value}:${operator}`);
-      });
-      this.updateRequest({ filter });
-    };
-    this.sorting = vue.computed(() => {
-      const requestData = this.requestData.value;
-      return {
-        sortColumn: requestData.sort,
-        sortDirection: requestData.sortDir ?? "asc"
-      };
+  };
+  const patch = (id, object2, options2) => {
+    return httpRequest.patch(getDataUri(id), object2, options2).then((response) => {
+      handleSuccess(`Saved ${notificationEntity}`);
+      return response.data;
+    }).catch((response) => {
+      handleError(response, `Failed to save ${notificationEntity}`);
     });
-    this.filters = vue.computed(
-      () => jsonFormsCore.extractFilters(this.requestData.value.filter)
-    );
-  }
-  get httpRequest() {
-    return toolsVue.useApi();
-  }
-  reload() {
-    this._reload.value = Date.now();
-  }
-  updatePage(page) {
-    this.updateRequest({ page });
-  }
-}
-const tableCache = /* @__PURE__ */ new Map();
-const useTableStore = (name) => {
-  const tableStore = tableCache.get(name);
-  if (tableStore) {
-    return tableStore;
-  }
-  const newTableStore = new TableStore();
-  tableCache.set(name, newTableStore);
-  return newTableStore;
-};
-const _hoisted_1$3 = {
-  key: 0,
-  class: "mb-2"
-};
-const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
-  __name: "table.component",
-  props: TableComponentProperties,
-  emits: TableComponentEmits,
-  setup(__props, { emit: __emit }) {
-    const properties = __props;
-    const emit = __emit;
-    vue.watch(
-      () => properties.reload,
-      () => {
-        store.reload();
-      }
-    );
-    let store = useTableStore(properties.id);
-    vue.watch(
-      () => properties.uri,
-      () => {
-        store.init(properties.uri);
-      },
-      { immediate: true }
-    );
-    const edit = (data) => {
-      emit("edit", data);
-    };
-    const deleteFn = (data) => {
-      emit("delete", data);
-    };
-    const components = {
-      TextCell: ui.TextCell
-    };
-    const displayColumns = vue.computed(() => {
-      return properties.uiSchema.elements.map((e) => {
-        const element = e;
-        const def = jsonFormsCore.findColumnDef(element, properties.schema);
-        const type = lodashEs.isArray(def.type) ? def.type[0] : def.type;
-        let component;
-        if (element.options?.format && element.options.format in components) {
-          component = components[element.options.format];
-        } else {
-          component = components[element.type];
-        }
-        if (!component) console.warn("No component found for type", element.type);
-        return {
-          ...def,
-          type,
-          component
-        };
-      });
+  };
+  const get = (id, options2) => {
+    return httpRequest.get(getDataUri(id), options2).then((response) => {
+      return response.data;
+    }).catch((response) => {
+      handleError(response, `Failed to load data`);
     });
-    const onChangeFilters = (filters) => {
-      store.updateFilters(filters);
-    };
-    const onUpdatePage = (page) => {
-      store.updatePage(page);
-    };
-    const onSort = (id) => {
-      store.sort(id);
-    };
-    const sort = vue.computed(() => {
-      return store.sorting.value ?? { orderBy: "", ascending: 1 };
+  };
+  const _delete = (id, options2) => {
+    return httpRequest.delete(getDataUri(id), options2).then((response) => {
+      handleSuccess(`${notificationEntity} deleted`);
+      return response;
+    }).catch((response) => {
+      handleError(response, `Failed to delete ${notificationEntity}`);
     });
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", null, [
-        _ctx.filterUiSchema && _ctx.filterSchema ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, [
-          vue.createVNode(_sfc_main$5, {
-            layout: { uiSchema: _ctx.filterUiSchema, schema: _ctx.filterSchema },
-            filters: vue.unref(store).filters.value,
-            onChangeFilters
-          }, null, 8, ["layout", "filters"])
-        ])) : vue.createCommentVNode("", true),
-        vue.createElementVNode("div", null, [
-          vue.createVNode(vue.unref(ui.Table), {
-            "display-columns": displayColumns.value,
-            sort: sort.value,
-            page: vue.unref(store).pageData.value,
-            loading: vue.unref(store).loading.value,
-            data: vue.unref(store).tableData.value,
-            actions: _ctx.actions,
-            onUpdatePage,
-            onDelete: deleteFn,
-            onEdit: edit,
-            onSort
-          }, null, 8, ["display-columns", "sort", "page", "loading", "data", "actions"])
-        ])
-      ]);
-    };
-  }
-});
-const _hoisted_1$2 = { class: "flex justify-between items-center mb-2" };
-const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
-  __name: "form-with-table.component",
-  props: FormWithTableProperties,
-  emits: FormWithTableEmits,
-  setup(__props, { emit: __emit }) {
-    const properties = __props;
-    const emit = __emit;
-    const reload = vue.ref(0);
-    const resolvedForm = vue.computed(() => properties.form);
-    const resolvedTable = vue.computed(() => properties.table);
-    const resolvedFilter = vue.computed(() => properties.filter);
-    const resolvedUri = vue.computed(() => properties.uri);
-    let store = new FormStore(resolvedUri.value ?? "");
-    vue.watch(resolvedUri, (uri) => {
-      store = new FormStore(uri ?? "");
+  };
+  const createMulti = (objects, options2) => {
+    return Promise.all(
+      objects.map((object2) => httpRequest.post(getDataUri(), object2, options2))
+    ).then((response) => {
+      handleSuccess(`Created ${notificationEntity}`);
+      return response.data;
+    }).catch((response) => {
+      handleError(response, `Failed to save ${notificationEntity}`);
     });
-    const hasEdit = ui.hasCustomEventListener("editData");
-    const customEdit = ui.hasCustomEventListener("custom:edit");
-    const customCreate = ui.hasCustomEventListener("custom:create");
-    const edit = (data) => {
-      if (customEdit) {
-        emit("custom:edit", data);
-        return;
-      }
-      if (hasEdit) {
-        emit("editData", data);
-        return;
-      }
-      openModal(data);
-    };
-    const create = () => {
-      if (customCreate) {
-        emit("custom:create");
-        return;
-      }
-      openModal();
-    };
-    const deleteFn = (data) => {
-      ui.ModalService.showConfirm({
-        title: "Delete record",
-        message: "Are you sure to delete, the data will be lost?",
-        onClose: (result) => {
-          if (result.confirmed) {
-            store.delete(data).then(() => {
-              reload.value = Date.now();
-              emit("delete", data);
-            });
-          }
-        }
-      });
-    };
-    const openModal = (formData) => {
-      if (!resolvedForm.value) return;
-      const isUpdate = !!formData?.id;
-      FormModalService.openModal({
-        schema: resolvedForm.value.schema,
-        uiSchema: resolvedForm.value.uiSchema,
-        modalSize: resolvedForm.value.modalSize,
-        initialData: formData ?? properties.initialData,
-        modalTitle: (isUpdate ? properties.updateTitle ?? properties.createTitle : properties.createTitle) ?? "",
-        onClose: (result) => {
-          if (result && result.valid) {
-            store.save(formData?.id, result.data).then(() => {
-              reload.value = Date.now();
-              emit("save", { id: formData?.id, data: result.data });
-            });
-          }
-        },
-        onEvents: (payload) => emit("events", payload)
-      });
-    };
-    return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
-        vue.createElementVNode("div", _hoisted_1$2, [
-          vue.createElementVNode("h1", null, vue.toDisplayString(_ctx.tableTitle), 1),
-          vue.createElementVNode("div", null, [
-            vue.createVNode(vue.unref(ui.Btn), {
-              icon: vue.unref(ui.IconEnum).Plus,
-              outline: true,
-              onClick: create
-            }, {
-              default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
-                vue.createTextVNode(" Add new record ", -1)
-              ])]),
-              _: 1
-            }, 8, ["icon"])
-          ])
-        ]),
-        resolvedTable.value ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Card), { key: 0 }, {
-          default: vue.withCtx(() => [
-            resolvedUri.value ? (vue.openBlock(), vue.createBlock(vue.unref(_sfc_main$4), {
-              key: 0,
-              id: `form_table_${_ctx.id}`,
-              "ui-schema": resolvedTable.value.uiSchema,
-              schema: resolvedTable.value.schema,
-              "filter-ui-schema": resolvedFilter.value?.uiSchema,
-              "filter-schema": resolvedFilter.value?.schema,
-              uri: _ctx.dataUri ?? resolvedUri.value,
-              reload: reload.value,
-              actions: _ctx.tableActions,
-              onEdit: edit,
-              onDelete: deleteFn
-            }, null, 8, ["id", "ui-schema", "schema", "filter-ui-schema", "filter-schema", "uri", "reload", "actions"])) : vue.createCommentVNode("", true)
-          ]),
-          _: 1
-        })) : vue.createCommentVNode("", true)
-      ], 64);
-    };
-  }
+  };
+  return { create, patch, createMulti, delete: _delete, get };
+};
+const createFormEvents = (dispatch) => ({
+  dispatch
 });
+const FORM_EVENTS_KEY = /* @__PURE__ */ Symbol("json-forms:events");
+const provideFormEvents = (dispatch) => {
+  const events = createFormEvents(dispatch);
+  vue.provide(FORM_EVENTS_KEY, events);
+  return events;
+};
+const useFormEvents = () => {
+  return vue.inject(
+    FORM_EVENTS_KEY,
+    createFormEvents(() => {
+    })
+  );
+};
 function $constructor(name, initializer2, params) {
   function init(inst, def) {
     if (!inst._zod) {
@@ -1659,7 +927,7 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
   }
   return { formErrors, fieldErrors };
 }
-function formatError(error2, mapper = (issue2) => issue2.message) {
+function formatError$1(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
   const processError = (error3) => {
     for (const issue2 of error3.issues) {
@@ -3112,11 +2380,11 @@ const $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
     return payload;
   };
 });
-function handleArrayResult(result, final, index) {
+function handleArrayResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
@@ -3607,14 +2875,14 @@ function mergeValues(a, b) {
       return { valid: false, mergeErrorPath: [] };
     }
     const newArray = [];
-    for (let index = 0; index < a.length; index++) {
-      const itemA = a[index];
-      const itemB = b[index];
+    for (let index2 = 0; index2 < a.length; index2++) {
+      const itemA = a[index2];
+      const itemB = b[index2];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [index2, ...sharedValue.mergeErrorPath]
         };
       }
       newArray.push(sharedValue.data);
@@ -3730,11 +2998,11 @@ const $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     return payload;
   };
 });
-function handleTupleResult(result, final, index) {
+function handleTupleResult(result, final, index2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues(index, result.issues));
+    final.issues.push(...prefixIssues(index2, result.issues));
   }
-  final.value[index] = result.value;
+  final.value[index2] = result.value;
 }
 const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
@@ -6332,7 +5600,7 @@ const initializer = (inst, issues) => {
   inst.name = "ZodError";
   Object.defineProperties(inst, {
     format: {
-      value: (mapper) => formatError(inst, mapper)
+      value: (mapper) => formatError$1(inst, mapper)
       // enumerable: false,
     },
     flatten: {
@@ -7952,244 +7220,1344 @@ function convertBaseSchema(schema, ctx) {
         }
         break;
       }
-      const objectSchema = z.object(shape);
-      if (schema.additionalProperties === false) {
-        zodSchema = objectSchema.strict();
-      } else if (typeof schema.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
-      } else {
-        zodSchema = objectSchema.passthrough();
+      const objectSchema = z.object(shape);
+      if (schema.additionalProperties === false) {
+        zodSchema = objectSchema.strict();
+      } else if (typeof schema.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+      } else {
+        zodSchema = objectSchema.passthrough();
+      }
+      break;
+    }
+    case "array": {
+      const prefixItems = schema.prefixItems;
+      const items = schema.items;
+      if (prefixItems && Array.isArray(prefixItems)) {
+        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
+        if (rest) {
+          zodSchema = z.tuple(tupleItems).rest(rest);
+        } else {
+          zodSchema = z.tuple(tupleItems);
+        }
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        }
+      } else if (Array.isArray(items)) {
+        const tupleItems = items.map((item) => convertSchema(item, ctx));
+        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
+        if (rest) {
+          zodSchema = z.tuple(tupleItems).rest(rest);
+        } else {
+          zodSchema = z.tuple(tupleItems);
+        }
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        }
+      } else if (items !== void 0) {
+        const element = convertSchema(items, ctx);
+        let arraySchema = z.array(element);
+        if (typeof schema.minItems === "number") {
+          arraySchema = arraySchema.min(schema.minItems);
+        }
+        if (typeof schema.maxItems === "number") {
+          arraySchema = arraySchema.max(schema.maxItems);
+        }
+        zodSchema = arraySchema;
+      } else {
+        zodSchema = z.array(z.any());
+      }
+      break;
+    }
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  if (schema.default !== void 0) {
+    zodSchema = zodSchema.default(schema.default);
+  }
+  return zodSchema;
+}
+function convertSchema(schema, ctx) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
+  }
+  let baseSchema = convertBaseSchema(schema, ctx);
+  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+    const anyOfUnion = z.union(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+    const oneOfUnion = z.xor(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    if (schema.allOf.length === 0) {
+      baseSchema = hasExplicitType ? baseSchema : z.any();
+    } else {
+      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      const startIdx = hasExplicitType ? 0 : 1;
+      for (let i = startIdx; i < schema.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+      }
+      baseSchema = result;
+    }
+  }
+  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+    baseSchema = z.nullable(baseSchema);
+  }
+  if (schema.readOnly === true) {
+    baseSchema = z.readonly(baseSchema);
+  }
+  const extraMeta = {};
+  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
+  for (const key of coreMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
+    }
+  }
+  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
+  for (const key of contentMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
+    }
+  }
+  for (const key of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key)) {
+      extraMeta[key] = schema[key];
+    }
+  }
+  if (Object.keys(extraMeta).length > 0) {
+    ctx.registry.add(baseSchema, extraMeta);
+  }
+  return baseSchema;
+}
+function fromJSONSchema(schema, params) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
+  }
+  const version2 = detectVersion(schema);
+  const defs = schema.$defs || schema.definitions || {};
+  const ctx = {
+    version: version2,
+    defs,
+    refs: /* @__PURE__ */ new Map(),
+    processing: /* @__PURE__ */ new Set(),
+    rootSchema: schema,
+    registry: globalRegistry
+  };
+  return convertSchema(schema, ctx);
+}
+config(en());
+const errorPatterns = [
+  [/^Invalid input: expected \w+, received undefined$/, "This field is required"],
+  [/^Invalid input: expected \w+, received null$/, "This field is required"],
+  [/^Expected string, received/, "Invalid value"],
+  [/^String must contain at least (\d+)/, "Must be at least $1 characters"],
+  [/^Number must be greater than or equal to (\d+)/, "Minimum value is $1"],
+  [/^Number must be less than or equal to (\d+)/, "Maximum value is $1"]
+];
+const formatError = (message) => {
+  if (!message) return void 0;
+  for (const [pattern, replacement] of errorPatterns) {
+    if (pattern.test(message)) {
+      return message.replace(pattern, replacement);
+    }
+  }
+  return message;
+};
+const registerZodErrorMap = () => {
+  config({
+    customError: (issue2) => {
+      if (issue2.code === "invalid_type" && issue2.received === "undefined") {
+        return { message: "This field is required" };
+      }
+      if (issue2.code === "invalid_type" && issue2.received === "null") {
+        return { message: "This field is required" };
+      }
+      if (issue2.code === "too_small") {
+        const i = issue2;
+        if (i.type === "string" && i.minimum === 1) {
+          return { message: "This field is required" };
+        }
+        if (i.type === "string") {
+          return { message: `Must be at least ${i.minimum} characters` };
+        }
+      }
+      if (issue2.code === "too_big") {
+        const i = issue2;
+        if (i.type === "string") {
+          return { message: `Must be at most ${i.maximum} characters` };
+        }
+      }
+      return { message: issue2.message };
+    }
+  });
+};
+function findRenderer(registry2, uischema, schema) {
+  let best = null;
+  for (const entry of registry2) {
+    const rank = entry.tester(uischema, schema);
+    if (rank > -1 && (!best || rank > best.rank)) {
+      best = { rank, renderer: entry.renderer };
+    }
+  }
+  return best?.renderer ?? null;
+}
+const scopeToPath = (scope) => {
+  if (!scope) return "";
+  return scope.replace(/^#\//, "").split("/").filter((s) => s !== "properties").join(".");
+};
+const resolveSchema = (root, scope) => {
+  const segments = scope.replace(/^#\//, "").split("/").filter(Boolean);
+  return segments.reduce((acc, key) => acc?.[key], root);
+};
+const _hoisted_1$6 = {
+  key: 1,
+  class: "text-error text-xs"
+};
+const _sfc_main$f = /* @__PURE__ */ vue.defineComponent({
+  __name: "Dispatch",
+  props: {
+    uischema: {},
+    schema: {},
+    pathPrefix: { default: void 0 }
+  },
+  setup(__props) {
+    const props = __props;
+    const registry2 = vue.inject("renderers");
+    const rootSchema = vue.inject("rootSchema");
+    const parentPrefix = vue.inject("pathPrefix", "");
+    const effectivePrefix = props.pathPrefix ?? parentPrefix;
+    if (props.pathPrefix !== void 0) {
+      vue.provide("pathPrefix", effectivePrefix);
+    }
+    const resolved = vue.computed(() => {
+      const u = props.uischema;
+      if (!u.scope) return props.schema;
+      const fromRoot = resolveSchema(rootSchema, u.scope);
+      if (fromRoot) return fromRoot;
+      return resolveSchema(props.schema, u.scope) ?? props.schema;
+    });
+    const renderer = vue.computed(
+      () => findRenderer(registry2, props.uischema, resolved.value)
+    );
+    return (_ctx, _cache) => {
+      return renderer.value ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderer.value), {
+        key: 0,
+        uischema: __props.uischema,
+        schema: resolved.value
+      }, null, 8, ["uischema", "schema"])) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$6, " No renderer for " + vue.toDisplayString(__props.uischema.scope ?? __props.uischema.type), 1));
+    };
+  }
+});
+const JsonFormComponentProperties = {
+  /** Unique identifier used to namespace the form element. */
+  id: { type: String, required: true },
+  /** HTML name attribute for the form. */
+  name: { type: String, default: "form" },
+  /** JSON schema describing the shape of the form data. */
+  schema: { type: Object, required: true },
+  /** UI schema describing the layout and controls. */
+  uiSchema: { type: Object, required: true },
+  /** Disable all form controls. */
+  disabled: { type: Boolean, default: false },
+  /** Current form data object. */
+  formData: { type: Object, default: () => ({}) },
+  /** When validation errors are shown (`'onBlur'`, `'onChange'`, `'onSubmit'`, `'always'`). */
+  errorMode: {
+    type: String,
+    default: "onChanges"
+  }
+};
+const JsonFormComponentEmits = [
+  /** Emitted when form data changes. */
+  "change",
+  /** Emitted on form submission. */
+  "submit",
+  /** Emitted when validation errors change. */
+  "errors",
+  /** Emitted when form validity changes. */
+  "valid",
+  /** Emitted when a custom renderer dispatches a form event. */
+  "events"
+];
+const ERROR_MODE_KEY = /* @__PURE__ */ Symbol("errorMode");
+const FORM_SUBMITTED_KEY = /* @__PURE__ */ Symbol("formSubmitted");
+const _hoisted_1$5 = { class: "flex-1" };
+const _hoisted_2$1 = { key: 0 };
+const _hoisted_3 = {
+  key: 0,
+  class: "text-sm text-base-content/50"
+};
+const _hoisted_4 = { key: 1 };
+const _sfc_main$e = /* @__PURE__ */ vue.defineComponent({
+  __name: "ArrayRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const parentPrefix = vue.inject("pathPrefix", "");
+    const scope = props.uischema.scope;
+    const scopePath = scopeToPath(scope);
+    const path = parentPrefix ? `${parentPrefix}.${scopePath}` : scopePath;
+    const rootSchema = vue.inject("rootSchema");
+    const arraySchema = resolveSchema(rootSchema, scope);
+    const itemSchema = arraySchema?.items ?? {};
+    const { fields, push, remove } = veeValidate.useFieldArray(path);
+    if (fields.value.length === 0) {
+      push({});
+    }
+    const opts = props.uischema.options ?? {};
+    const layout = opts.layout ?? "column";
+    const showActions = vue.computed(() => !opts.hideActions);
+    const detail = vue.computed(
+      () => props.uischema._detail ?? opts.detail
+    );
+    const childElements = vue.computed(() => {
+      if (!detail.value) {
+        return props.uischema.elements ?? [];
+      }
+      const type = detail.value.type;
+      if (type && type !== "Control") {
+        return [detail.value];
+      }
+      return detail.value.elements ?? [detail.value];
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", null, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass([
+            "flex gap-2",
+            vue.unref(layout) === "row" ? "flex-row items-center" : "flex-col"
+          ])
+        }, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(fields), (entry, index2) => {
+            return vue.openBlock(), vue.createElementBlock("div", {
+              key: entry.key,
+              class: "flex-1"
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass([
+                  "flex gap-2",
+                  vue.unref(layout) === "row" ? "flex-col" : "flex-row items-center"
+                ])
+              }, [
+                vue.createElementVNode("div", _hoisted_1$5, [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(childElements.value, (child, ci) => {
+                    return vue.openBlock(), vue.createBlock(_sfc_main$f, {
+                      key: ci,
+                      uischema: child,
+                      schema: vue.unref(itemSchema),
+                      "path-prefix": `${vue.unref(path)}[${index2}]`
+                    }, null, 8, ["uischema", "schema", "path-prefix"]);
+                  }), 128))
+                ]),
+                showActions.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$1, [
+                  vue.unref(fields).length > 1 ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
+                    key: 0,
+                    icon: vue.unref(ui.IconEnum).Delete,
+                    outline: true,
+                    onClick: ($event) => vue.unref(remove)(index2)
+                  }, null, 8, ["icon", "onClick"])) : vue.createCommentVNode("", true)
+                ])) : vue.createCommentVNode("", true)
+              ], 2)
+            ]);
+          }), 128)),
+          vue.unref(fields).length === 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, " No data ")) : vue.createCommentVNode("", true),
+          showActions.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4, [
+            vue.createVNode(vue.unref(ui.Btn), {
+              icon: vue.unref(ui.IconEnum).Plus,
+              outline: true,
+              onClick: _cache[0] || (_cache[0] = ($event) => vue.unref(push)({}))
+            }, {
+              default: vue.withCtx(() => [..._cache[1] || (_cache[1] = [
+                vue.createTextVNode(" Add ", -1)
+              ])]),
+              _: 1
+            }, 8, ["icon"])
+          ])) : vue.createCommentVNode("", true)
+        ], 2)
+      ]);
+    };
+  }
+});
+const isAutoCompleteControl = testers.and(
+  // uiTypeIs('Control'),
+  testers.optionIs("format", jsonFormsCore.ControlType.autocomplete)
+);
+const isTextAreaControl = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.optionIs("format", jsonFormsCore.ControlType.textArea)
+);
+const isStringFormat = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.or(testers.optionIs("format", jsonFormsCore.ControlType.string), testers.schemaTypeIs("string"))
+);
+const isMarkdownControl = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.optionIs("format", jsonFormsCore.ControlType.markdown)
+);
+const isArrayRenderer = testers.and(
+  testers.schemaTypeIs("array")
+  // optionIs('format', ControlType.array),
+);
+const isMultiselectControl = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.optionIs("format", jsonFormsCore.ControlType.mutliSelect)
+);
+const isSelectControl = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.optionIs("format", jsonFormsCore.ControlType.select)
+);
+const isBooleanControl = testers.or(
+  testers.isBooleanControl,
+  testers.and(core$1.uiTypeIs("Control"), testers.optionIs("format", jsonFormsCore.ControlType.boolean))
+);
+const isNumberFormat = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.or(testers.optionIs("format", jsonFormsCore.ControlType.number), testers.schemaTypeIs("number"))
+);
+const isIntegerFormat = testers.and(
+  core$1.uiTypeIs("Control"),
+  testers.or(testers.optionIs("format", jsonFormsCore.ControlType.integer), testers.schemaTypeIs("integer"))
+);
+const arrayRenderers = [
+  { tester: core$1.rankWith(12, isArrayRenderer), renderer: _sfc_main$e }
+];
+const MethodSchema = _enum(["get", "post", "delete", "put", "patch"]);
+const OperationSchema = object({
+  uri: string(),
+  method: MethodSchema
+});
+const OperationsSchema = string().or(OperationSchema);
+const BooleanOperationSchema = boolean().or(OperationSchema).optional().default(false);
+const Operations = object({
+  findAll: BooleanOperationSchema,
+  findOne: BooleanOperationSchema,
+  create: BooleanOperationSchema,
+  update: BooleanOperationSchema,
+  delete: BooleanOperationSchema,
+  lookup: OperationsSchema.optional()
+});
+const OperationMap = {
+  create: "post",
+  delete: "delete",
+  findAll: "get",
+  findOne: "get",
+  lookup: "get",
+  update: "get"
+};
+const ResourceSchema = object({
+  id: string(),
+  uri: string(),
+  operations: Operations,
+  schema: object({
+    ui: any().optional(),
+    data: any()
+  }).optional()
+}).transform((data) => {
+  const schema = data.schema;
+  if (schema) {
+    if (!schema.ui) {
+      schema.ui = jsonFormsCore.uiFromJsonSchema(schema.data);
+    }
+  }
+  const operations = {};
+  for (const k in OperationMap) {
+    const key = k;
+    const defaultOperation = OperationMap[key];
+    const operation = data.operations[key];
+    const mapResourceSchema = () => {
+      if (lodashEs.isUndefined(operation) || operation === false) return null;
+      if (operation === true)
+        return { uri: data.uri, method: defaultOperation };
+      if (typeof operation === "string")
+        return { uri: operation, method: "get" };
+      return {
+        uri: operation.uri,
+        method: operation.method ?? defaultOperation
+      };
+    };
+    operations[key] = mapResourceSchema();
+  }
+  return {
+    ...data,
+    schema,
+    operations
+  };
+});
+const getResourceSchema = async (resourceUri, skipAuth) => {
+  const fetch = skipAuth ? axios : toolsVue.useApi();
+  return fetch.get(resourceUri).then((response) => {
+    const resource = ResourceSchema.safeParse(response.data);
+    if (!resource.success)
+      throw new Error(`Invalid resource schema: ${resource.error}`);
+    return resource.data;
+  });
+};
+const useRemoteOption = (options) => {
+  return {
+    fetchOptions: (searchTerm, signal) => {
+      const fetch = options.skipAuth ? axios : toolsVue.useApi();
+      return fetch.get(`${options.uri}${searchTerm}`, { signal }).then((data) => data.data[options.dataField ?? "data"]);
+    }
+  };
+};
+const useResourceOptions = async (options) => {
+  const resource = await getResourceSchema(
+    options.resource,
+    options.skipAuth ?? false
+  );
+  const fetch = options.skipAuth ? axios : toolsVue.useApi();
+  const lookup = resource.operations.lookup;
+  return {
+    fetchOptions: (searchTerm, signal) => {
+      const uri = lookup.uri.replace("{text}", searchTerm);
+      const method = lookup.method;
+      return fetch[method](uri, { signal }).then(
+        (data) => data.data[options.dataField ?? "data"]
+      );
+    },
+    enableCreate: !!resource.operations.create,
+    form: resource.operations.create ? {
+      ui_schema: resource.schema.ui,
+      json_schema: resource.schema.data,
+      title: `Create new ${resource.id}`,
+      create: async (data) => {
+        const create = resource.operations.create;
+        return fetch[create.method](create.uri, data).then(
+          (result) => result.data
+        );
+      }
+    } : null
+  };
+};
+const useFetchOptions = async (options) => {
+  let config2 = {};
+  if (options.uri)
+    config2 = useRemoteOption(options);
+  if (options.resource)
+    config2 = await useResourceOptions(options);
+  return {
+    fetchOptions: null,
+    labelKey: options.labelKey,
+    valueKey: options.valueKey,
+    enableCreate: options.enableCreate ?? false,
+    form: null,
+    ...config2
+  };
+};
+const checkRequired = (rootSchema, scope, fieldName) => {
+  const segments = scope.replace(/^#\//, "").split("/");
+  const parentSegments = segments.slice(0, -2);
+  if (parentSegments.length === 0) {
+    const req2 = rootSchema?.required;
+    return Array.isArray(req2) && req2.includes(fieldName);
+  }
+  const parentScope = `#/${parentSegments.join("/")}`;
+  const parentSchema = resolveSchema(rootSchema, parentScope);
+  const req = parentSchema?.required;
+  return Array.isArray(req) && req.includes(fieldName);
+};
+const useInputProps = (uischema, schema, field, options = {}) => {
+  const rootSchema = vue.inject("rootSchema");
+  const path = scopeToPath(uischema.scope);
+  const { errorMessage, meta: meta2 } = field;
+  const opts = uischema.options ?? {};
+  const labelFromScope = path.split(".").pop() ?? "";
+  const isRequired = rootSchema ? checkRequired(rootSchema, uischema.scope, labelFromScope) : false;
+  const s = schema ?? {};
+  const inferredType = (() => {
+    if (opts.format === "text") return "text";
+    if (s.format === "email") return "email";
+    if (s.format === "uri") return "url";
+    if (s.type === "number" || s.type === "integer") return "number";
+    return options.defaultType ?? "text";
+  })();
+  const styles = ui.mergeStyles(opts.styles);
+  const errorMode = vue.inject(ERROR_MODE_KEY, vue.ref("onBlur"));
+  const submitted = vue.inject(FORM_SUBMITTED_KEY, vue.ref(false));
+  const shouldShowError = vue.computed(() => {
+    if (!errorMessage.value) return false;
+    switch (errorMode.value) {
+      case "always":
+        return true;
+      case "onChange":
+        return meta2.dirty;
+      case "onSubmit":
+        return submitted.value;
+      case "onBlur":
+      default:
+        return meta2.touched;
+    }
+  });
+  const width = opts.colspan || styles?.width === "full" ? "w-full" : opts.width ?? "min-w-input";
+  return vue.computed(() => ({
+    id: path,
+    placeholder: opts.placeholder,
+    description: s.description,
+    errors: shouldShowError.value ? opts.errorMessage ?? formatError(errorMessage.value) : void 0,
+    label: opts.label ?? labelFromScope.charAt(0).toUpperCase() + labelFromScope.slice(1),
+    visible: opts.visible ?? true,
+    required: isRequired,
+    enabled: opts.readonly !== true,
+    isFocused: false,
+    isTouched: shouldShowError.value,
+    hideLabel: opts.hideLabel ?? false,
+    styles,
+    width,
+    type: inferredType,
+    ...options.overrides
+  }));
+};
+const useCustomControlBinding = ({
+  useProps,
+  setDefaultValue
+} = {}) => {
+  return (uischema, schema, options = {}) => {
+    const pathPrefix = vue.inject("pathPrefix", "");
+    const scopePath = scopeToPath(uischema.scope);
+    const path = pathPrefix ? `${pathPrefix}.${scopePath}` : scopePath;
+    const field = veeValidate.useField(() => path);
+    setDefaultValue?.(field);
+    const wrapper = useInputProps(uischema, schema, field, options);
+    const customWrapper = useProps?.(uischema, schema, field, options) ?? {
+      value: {}
+    };
+    const onBlur = () => field.handleBlur(new Event("blur"));
+    const onChange = () => field.handleChange(field.value.value);
+    let initialized = false;
+    vue.watch(field.value, (val) => {
+      if (!initialized) {
+        initialized = true;
+        return;
       }
-      break;
+      field.handleChange(val);
+    });
+    return {
+      wrapper: vue.computed(() => ({ ...wrapper.value, ...customWrapper.value })),
+      value: field.value,
+      field,
+      onBlur,
+      onChange,
+      appliedOptions: vue.computed(
+        () => uischema.options ?? {}
+      )
+    };
+  };
+};
+const useControlBinding = (uischema, schema, options = {}) => {
+  return useCustomControlBinding()(uischema, schema, options);
+};
+const useSelectInput = (...fields) => (uischema, schema, field) => {
+  const opts = uischema.options ?? {};
+  return vue.computed(() => {
+    return lodashEs.pick(opts, fields);
+  });
+};
+const useSelectBinding = useCustomControlBinding({
+  useProps: useSelectInput("options", "labelKey", "valueKey")
+});
+const useAutocompleteBinding = useCustomControlBinding({
+  useProps: useSelectInput(
+    "options",
+    "labelKey",
+    "valueKey",
+    "uri",
+    "freeText",
+    "enableCreate",
+    "dataField",
+    "skipAuth"
+  )
+});
+const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
+  __name: "FormModal",
+  props: /* @__PURE__ */ vue.mergeModels(FormModalProperties, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ vue.mergeModels(FormModalEmits, ["update:modelValue"]),
+  setup(__props, { emit: __emit }) {
+    const properties = __props;
+    const id = `modal_${Math.floor(Math.random() * 1e3)}`;
+    const formRef = vue.ref();
+    const valid = vue.ref(false);
+    const formData = vue.useModel(__props, "modelValue");
+    const emits = __emit;
+    if (properties.data) {
+      formData.value = properties.data;
     }
-    case "array": {
-      const prefixItems = schema.prefixItems;
-      const items = schema.items;
-      if (prefixItems && Array.isArray(prefixItems)) {
-        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
-        if (rest) {
-          zodSchema = z.tuple(tupleItems).rest(rest);
-        } else {
-          zodSchema = z.tuple(tupleItems);
-        }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
-        }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-        }
-      } else if (Array.isArray(items)) {
-        const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
-        if (rest) {
-          zodSchema = z.tuple(tupleItems).rest(rest);
-        } else {
-          zodSchema = z.tuple(tupleItems);
-        }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
-        }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-        }
-      } else if (items !== void 0) {
-        const element = convertSchema(items, ctx);
-        let arraySchema = z.array(element);
-        if (typeof schema.minItems === "number") {
-          arraySchema = arraySchema.min(schema.minItems);
-        }
-        if (typeof schema.maxItems === "number") {
-          arraySchema = arraySchema.max(schema.maxItems);
-        }
-        zodSchema = arraySchema;
-      } else {
-        zodSchema = z.array(z.any());
+    const onCancel = () => {
+      formData.value = {};
+      emits("closeModal", null);
+    };
+    const onChange = (data) => {
+      formData.value = data;
+    };
+    const onSubmit = () => {
+      formRef.value?.markSubmitted();
+      if (!valid.value) return;
+      emits("closeModal", { data: formData.value, valid: valid.value });
+    };
+    const onErrors = (errors) => {
+      emits("errors", errors);
+      valid.value = lodashEs.isEmpty(errors);
+    };
+    vue.watch(valid, (newValid, oldValid) => {
+      if (newValid !== oldValid) {
+        emits("valid", newValid);
       }
-      break;
-    }
-    default:
-      throw new Error(`Unsupported type: ${type}`);
-  }
-  if (schema.description) {
-    zodSchema = zodSchema.describe(schema.description);
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.Modal), vue.mergeProps(properties, {
+        open: true,
+        "disable-close": false,
+        width: _ctx.modalSize,
+        onCloseModal: onCancel
+      }), {
+        content: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "content-before"),
+          vue.createVNode(_sfc_main$2, {
+            id: `modal-${id}`,
+            ref_key: "formRef",
+            ref: formRef,
+            "form-data": formData.value,
+            schema: _ctx.schema,
+            "ui-schema": _ctx.uiSchema,
+            "error-mode": _ctx.errorMode,
+            onErrors,
+            onChange,
+            onEvents: _cache[0] || (_cache[0] = ($event) => emits("events", $event))
+          }, null, 8, ["id", "form-data", "schema", "ui-schema", "error-mode"]),
+          vue.renderSlot(_ctx.$slots, "content-after")
+        ]),
+        actions: vue.withCtx(() => [
+          vue.createVNode(vue.unref(ui.Btn), {
+            color: vue.unref(ui.Color).secondary,
+            outline: true,
+            "aria-label": "Cancel",
+            onClick: onCancel
+          }, {
+            default: vue.withCtx(() => [..._cache[1] || (_cache[1] = [
+              vue.createTextVNode(" Cancel ", -1)
+            ])]),
+            _: 1
+          }, 8, ["color"]),
+          vue.createVNode(vue.unref(ui.Btn), {
+            disabled: !valid.value,
+            "aria-label": "Save",
+            onClick: onSubmit
+          }, {
+            default: vue.withCtx(() => [..._cache[2] || (_cache[2] = [
+              vue.createTextVNode(" Save ", -1)
+            ])]),
+            _: 1
+          }, 8, ["disabled"])
+        ]),
+        _: 3
+      }, 16, ["width"]);
+    };
   }
-  if (schema.default !== void 0) {
-    zodSchema = zodSchema.default(schema.default);
+});
+class JsonFormModalService {
+  static openModal({
+    initialData,
+    modalTitle,
+    schema,
+    uiSchema,
+    modalSize,
+    onClose,
+    onEvents
+  }) {
+    ui.ModalService.openModal({
+      component: _sfc_main$d,
+      props: {
+        schema,
+        uiSchema,
+        modalSize,
+        data: initialData ?? {},
+        modalTitle,
+        onClose,
+        onEvents
+      }
+    });
   }
-  return zodSchema;
 }
-function convertSchema(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+const _sfc_main$c = /* @__PURE__ */ vue.defineComponent({
+  __name: "AutocompleteControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      wrapper,
+      value,
+      field,
+      onBlur,
+      onChange: onFieldChange,
+      appliedOptions
+    } = useAutocompleteBinding(props.uischema, props.schema);
+    const fetchOptions = core.computedAsync(async () => {
+      const config2 = await useFetchOptions(
+        appliedOptions.value
+      );
+      return config2;
+    });
+    const onChange = (val) => {
+      field.setValue(val);
+      onFieldChange();
+    };
+    const formEvents = useFormEvents();
+    const path = scopeToPath(props.uischema.scope);
+    const onCreate = () => {
+      if (fetchOptions.value?.enableCreate === false) return;
+      const form = fetchOptions.value.form;
+      if (form) {
+        JsonFormModalService.openModal({
+          schema: form.json_schema,
+          uiSchema: form.ui_schema,
+          modalTitle: `Create new ${wrapper.value.label}`,
+          onClose: (result) => {
+            if (!result || !result.valid) return;
+            form.create(result.data).then((res) => {
+              field.setValue(res);
+            });
+          }
+        });
+        return;
+      }
+      formEvents.dispatch({
+        event: "create",
+        type: path,
+        data: value.value,
+        onSuccess: (result) => {
+          field.setValue(result);
+        }
+      });
+    };
+    return (_ctx, _cache) => {
+      return vue.unref(fetchOptions) ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Autocomplete), vue.mergeProps({ key: 0 }, vue.unref(wrapper), {
+        "model-value": vue.unref(value),
+        "fetch-options": vue.unref(fetchOptions).fetchOptions,
+        "label-key": vue.unref(fetchOptions).labelKey,
+        "value-key": vue.unref(fetchOptions).valueKey,
+        "enable-create": vue.unref(fetchOptions).enableCreate,
+        onChange,
+        onBlur: vue.unref(onBlur),
+        onCreate
+      }), null, 16, ["model-value", "fetch-options", "label-key", "value-key", "enable-create", "onBlur"])) : vue.createCommentVNode("", true);
+    };
   }
-  let baseSchema = convertBaseSchema(schema, ctx);
-  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
-  if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z.union(options);
-    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+});
+const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
+  __name: "BooleanControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const useBooleanBinding = useCustomControlBinding({
+      setDefaultValue: (field2) => {
+        if (field2.value.value === void 0) field2.setValue(false);
+      }
+    });
+    const { wrapper, value, field, onBlur, onChange: onFieldChange } = useBooleanBinding(props.uischema, props.schema);
+    const onChange = (val) => {
+      field.setValue(Boolean(val) ?? false);
+      onFieldChange();
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.Checkbox), vue.mergeProps(vue.unref(wrapper), {
+        "model-value": vue.unref(value),
+        onChange,
+        onBlur: vue.unref(onBlur)
+      }), null, 16, ["model-value", "onBlur"]);
+    };
+  }
+});
+const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
+  __name: "MarkdownControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      wrapper,
+      value,
+      field,
+      onBlur,
+      onChange: onFieldChange
+    } = useControlBinding(props.uischema, props.schema);
+    const onChange = (val) => {
+      field.setValue(val);
+      onFieldChange();
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.Markdown), vue.mergeProps(vue.unref(wrapper), {
+        "model-value": vue.unref(value),
+        onChange,
+        onBlur: vue.unref(onBlur)
+      }), null, 16, ["model-value", "onBlur"]);
+    };
   }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z.xor(options);
-    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+});
+const _sfc_main$9 = /* @__PURE__ */ vue.defineComponent({
+  __name: "MultiSelectControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      wrapper,
+      value,
+      field,
+      onBlur,
+      onChange: onFieldChange
+    } = useSelectBinding(props.uischema, props.schema);
+    const onChange = (val) => {
+      field.setValue(val);
+      onFieldChange();
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.MultiSelect), vue.mergeProps(vue.unref(wrapper), {
+        "model-value": vue.unref(value),
+        onChange,
+        onBlur: vue.unref(onBlur)
+      }), null, 16, ["model-value", "onBlur"]);
+    };
   }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z.any();
-    } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
-      const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
-      }
-      baseSchema = result;
-    }
+});
+const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
+  __name: "NumberControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { wrapper, value, onBlur, onChange } = useControlBinding(
+      props.uischema,
+      props.schema,
+      { defaultType: "number" }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.InputNumber), vue.mergeProps(vue.unref(wrapper), {
+        modelValue: vue.unref(value),
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null),
+        steps: 0.01,
+        onBlur: vue.unref(onBlur),
+        onChange: vue.unref(onChange)
+      }), null, 16, ["modelValue", "onBlur", "onChange"]);
+    };
   }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z.nullable(baseSchema);
+});
+const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
+  __name: "SelectControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      wrapper,
+      value,
+      field,
+      onBlur,
+      onChange: onFieldChange,
+      appliedOptions
+    } = useSelectBinding(props.uischema, props.schema);
+    const selectOptions = vue.computed(() => {
+      return appliedOptions.options ?? [];
+    });
+    const onChange = (val) => {
+      field.setValue(val);
+      onFieldChange();
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.SelectComponent), vue.mergeProps(vue.unref(wrapper), {
+        "model-value": vue.unref(value),
+        options: selectOptions.value,
+        onChange,
+        onBlur: vue.unref(onBlur)
+      }), null, 16, ["model-value", "options", "onBlur"]);
+    };
   }
-  if (schema.readOnly === true) {
-    baseSchema = z.readonly(baseSchema);
+});
+const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
+  __name: "StringControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { wrapper, value, onBlur, onChange } = useControlBinding(
+      props.uischema,
+      props.schema
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.Input), vue.mergeProps(vue.unref(wrapper), {
+        modelValue: vue.unref(value),
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null),
+        onBlur: vue.unref(onBlur),
+        onChange: vue.unref(onChange)
+      }), null, 16, ["modelValue", "onBlur", "onChange"]);
+    };
   }
-  const extraMeta = {};
-  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
+});
+const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
+  __name: "TextAreaControlRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { wrapper, value, onBlur, onChange } = useControlBinding(
+      props.uischema,
+      props.schema
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.Textarea), vue.mergeProps(vue.unref(wrapper), {
+        modelValue: vue.unref(value),
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null),
+        onBlur: vue.unref(onBlur),
+        onChange: vue.unref(onChange)
+      }), null, 16, ["modelValue", "onBlur", "onChange"]);
+    };
   }
-  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
+});
+const index = [
+  { tester: core$1.rankWith(10, isStringFormat), renderer: _sfc_main$6 },
+  {
+    tester: core$1.rankWith(11, isTextAreaControl),
+    renderer: _sfc_main$5
+  },
+  {
+    tester: core$1.rankWith(11, isMarkdownControl),
+    renderer: _sfc_main$a
+  },
+  { tester: core$1.rankWith(11, isBooleanControl), renderer: _sfc_main$b },
+  { tester: core$1.rankWith(11, isSelectControl), renderer: _sfc_main$7 },
+  {
+    tester: core$1.rankWith(11, isMultiselectControl),
+    renderer: _sfc_main$9
+  },
+  {
+    tester: core$1.rankWith(12, isAutoCompleteControl),
+    renderer: _sfc_main$c
+  },
+  {
+    tester: core$1.rankWith(12, isNumberFormat),
+    renderer: _sfc_main$8
+  },
+  {
+    tester: core$1.rankWith(12, isIntegerFormat),
+    renderer: _sfc_main$8
   }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
-    }
+];
+const COLSPAN = {
+  1: "col-span-1",
+  2: "col-span-2",
+  3: "col-span-3",
+  4: "col-span-4",
+  5: "col-span-5",
+  6: "col-span-6",
+  7: "col-span-7",
+  8: "col-span-8",
+  9: "col-span-9",
+  10: "col-span-10",
+  11: "col-span-11",
+  12: "col-span-12"
+};
+const _hoisted_1$4 = { class: "flex flex-col gap-4" };
+const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+  __name: "CollapseLayoutRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const pathPrefix = vue.inject("pathPrefix", "");
+    const opts = props.uischema.options ?? {};
+    const titleKeyField = opts.titleKey ? veeValidate.useFieldValue(
+      () => pathPrefix ? `${pathPrefix}.${opts.titleKey}` : opts.titleKey
+    ) : void 0;
+    const title = vue.computed(() => {
+      if (titleKeyField?.value) return titleKeyField.value;
+      return props.uischema.label ?? opts.title ?? "Details";
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ui.Collapse), { title: title.value }, {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("div", _hoisted_1$4, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.uischema.elements, (child, i) => {
+              return vue.openBlock(), vue.createElementBlock("div", {
+                key: i,
+                class: vue.normalizeClass(vue.unref(COLSPAN)[child.options?.colspan ?? 12])
+              }, [
+                vue.createVNode(_sfc_main$f, {
+                  uischema: child,
+                  schema: __props.schema
+                }, null, 8, ["uischema", "schema"])
+              ], 2);
+            }), 128))
+          ])
+        ]),
+        _: 1
+      }, 8, ["title"]);
+    };
   }
-  if (Object.keys(extraMeta).length > 0) {
-    ctx.registry.add(baseSchema, extraMeta);
+});
+const _hoisted_1$3 = {
+  key: 1,
+  class: "flex flex-col gap-3"
+};
+const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "LayoutRenderer",
+  props: {
+    uischema: {},
+    schema: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const LAYOUT = {
+      GridLayout: "grid grid-cols-12 gap-3",
+      HorizontalLayout: "flex flex-row gap-3",
+      VerticalLayout: "flex flex-col gap-3"
+    };
+    const getLayout = vue.computed(() => LAYOUT[props.uischema.type]);
+    const isLayout = vue.computed(() => props.uischema.type in LAYOUT);
+    return (_ctx, _cache) => {
+      return isLayout.value ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        class: vue.normalizeClass(getLayout.value)
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.uischema.elements, (child, i) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: i,
+            class: vue.normalizeClass(vue.unref(COLSPAN)[child.options?.colspan ?? 12])
+          }, [
+            vue.createVNode(_sfc_main$f, {
+              uischema: child,
+              schema: __props.schema
+            }, null, 8, ["uischema", "schema"])
+          ], 2);
+        }), 128))
+      ], 2)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, " No Applicable Layout found "));
+    };
   }
-  return baseSchema;
-}
-function fromJSONSchema(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+});
+const isLayoutType = core$1.or(
+  core$1.uiTypeIs("GridLayout"),
+  core$1.uiTypeIs("HorizontalLayout"),
+  core$1.uiTypeIs("VerticalLayout")
+);
+const layoutRenderes = [
+  { tester: core$1.rankWith(10, isLayoutType), renderer: _sfc_main$3 },
+  {
+    tester: core$1.rankWith(10, core$1.uiTypeIs("CollapseLayout")),
+    renderer: _sfc_main$4
   }
-  const version2 = detectVersion(schema);
-  const defs = schema.$defs || schema.definitions || {};
-  const ctx = {
-    version: version2,
-    defs,
-    refs: /* @__PURE__ */ new Map(),
-    processing: /* @__PURE__ */ new Set(),
-    rootSchema: schema,
-    registry: globalRegistry
-  };
-  return convertSchema(schema, ctx);
-}
-config(en());
-const customRenderers = [
-  controlRenderers,
-  layoutRenderers,
-  // ...complexRenderers,
-  arrayRenderers
-  // ...labelRenderers,
-].flat();
-const tailwindRenderers = [
-  ...vueVanilla.vanillaRenderers,
-  ...customRenderers
 ];
-const _hoisted_1$1 = ["id"];
+const customRenderes = [layoutRenderes, index, arrayRenderers].flat();
+const _hoisted_1$2 = ["id"];
 const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
-  __name: "form.component",
-  props: FormComponentProperties,
-  emits: FormComponentEmits,
-  setup(__props, { emit: __emit }) {
+  __name: "FormComponent",
+  props: JsonFormComponentProperties,
+  emits: JsonFormComponentEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    registerZodErrorMap();
     const properties = __props;
     const emits = __emit;
-    const valid = vue.ref(false);
-    const zodSchema = vue.computed(() => fromJSONSchema(properties.schema));
-    const stripFormData = (data) => {
-      const safeParse2 = zodSchema.value?.strip().safeParse(data);
-      return safeParse2?.success ? safeParse2.data : data ?? {};
-    };
-    const internalFormData = vue.ref(properties.formData ?? {});
+    const zodSchema = vue.computed(() => {
+      if (!properties.schema) return void 0;
+      try {
+        const patched = jsonFormsCore.enforceRequiredStringMinLength(properties.schema);
+        return fromJSONSchema(patched);
+      } catch {
+        return void 0;
+      }
+    });
+    const { values, errors, meta: meta2, setValues, validate } = veeValidate.useForm({
+      validationSchema: zodSchema,
+      initialValues: properties.formData
+    });
+    vue.provide("renderers", customRenderes);
+    vue.provide("rootSchema", properties.schema);
+    vue.provide("styles", ui.myStyles);
+    const submitted = vue.ref(false);
+    vue.provide(ERROR_MODE_KEY, vue.toRef(properties, "errorMode"));
+    vue.provide(FORM_SUBMITTED_KEY, submitted);
+    vue.onMounted(async () => {
+      const result = await validate();
+      emits("valid", result.valid);
+    });
+    provideFormEvents((payload) => {
+      emits("events", payload);
+    });
+    let syncing = false;
     vue.watch(
       () => properties.formData,
-      (data, oldData) => {
-        if (JSON.stringify(data) === JSON.stringify(internalFormData.value)) return;
-        internalFormData.value = stripFormData(data);
-        emits("change", internalFormData.value);
+      (newData) => {
+        if (!newData) return;
+        if (JSON.stringify(newData) === JSON.stringify(vue.toRaw(values))) return;
+        syncing = true;
+        setValues(newData);
+        vue.nextTick(() => {
+          syncing = false;
+        });
       },
-      { deep: true, immediate: true }
+      { deep: true }
     );
-    provideFormEvents((payload) => {
-      emits("events", payload);
-    });
-    const onChange = (event) => {
-      internalFormData.value = event.data;
-      valid.value = event.errors.length === 0;
-      emits("valid", valid.value);
-      emits("change", internalFormData.value);
-      emits("errors", event.errors);
-      toolsVue.Debugger.debug(event.errors);
-    };
-    const onSubmit = (event) => {
-      event.preventDefault();
+    vue.watch(
+      values,
+      (newValues) => {
+        if (syncing) return;
+        const isValid = meta2.value.valid;
+        emits("valid", isValid);
+        emits("change", vue.toRaw(newValues));
+      },
+      { deep: true }
+    );
+    vue.watch(
+      errors,
+      (newErrors) => {
+        const errorList = Object.entries(newErrors).filter(([, msg]) => !!msg).map(([path, message]) => ({ path, message }));
+        emits("errors", errorList);
+      },
+      { deep: true }
+    );
+    const onSubmit = () => {
+      submitted.value = true;
       emits("submit", {
-        data: internalFormData.value,
-        valid: valid.value
+        data: vue.toRaw(values),
+        valid: meta2.value.valid
       });
     };
-    vue.provide("styles", ui.myStyles);
-    const renderers = Object.freeze([
-      ...properties.renderers ?? [],
-      ...tailwindRenderers
-    ]);
+    const markSubmitted = () => {
+      submitted.value = true;
+    };
+    __expose({ markSubmitted });
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createElementBlock("form", {
         id: _ctx.id,
         onSubmit: vue.withModifiers(onSubmit, ["prevent"])
       }, [
-        (vue.openBlock(), vue.createBlock(vue.unref(vue$1.JsonForms), {
-          key: _ctx.id,
-          data: internalFormData.value,
-          schema: _ctx.schema,
+        vue.createVNode(_sfc_main$f, {
           uischema: _ctx.uiSchema,
-          renderers: vue.unref(renderers),
-          enabled: !_ctx.disabled,
-          onChange,
-          onSubmit
-        }, null, 8, ["data", "schema", "uischema", "renderers", "enabled"]))
-      ], 40, _hoisted_1$1);
+          schema: _ctx.schema
+        }, null, 8, ["uischema", "schema"])
+      ], 40, _hoisted_1$2);
     };
   }
 });
-const _hoisted_1 = { class: "flex justify-end gap-2 p-2 mt-2 border-t border-gray-300 z-[30] shrink-0" };
+const FormWithActionsProperties = {
+  /** Unique identifier used to namespace the inner form element. */
+  id: { type: String, required: true },
+  /** Title shown when creating a new record. */
+  createTitle: { type: String, required: true },
+  /** Title shown when editing an existing record. Falls back to `createTitle` when omitted. */
+  updateTitle: { type: String },
+  /** JSON schema describing the shape of the form data. */
+  schema: { type: Object },
+  /** UI schema describing the layout and controls. */
+  uiSchema: { type: Object },
+  /** REST endpoint used by `FormStore` to persist data. When omitted the form emits `submit` instead. */
+  uri: { type: String },
+  /** Enable vertical scrolling inside the form area. */
+  scrollable: { type: Boolean, default: false },
+  /** Stretch the collapse wrapper to full height. */
+  fullHeight: { type: Boolean, default: false },
+  /** Two-way bound form data object. */
+  modelValue: { type: Object, default: () => ({}) },
+  /** When validation errors are shown (`'onBlur'`, `'onChange'`, `'onSubmit'`, `'always'`). */
+  errorMode: {
+    type: String,
+    default: "onBlur"
+  }
+};
+const FormWithActionsEmits = [
+  /** Emitted when `modelValue` changes. */
+  "update:modelValue",
+  /** Emitted after a successful `FormStore.save()`. */
+  "success",
+  /** Emitted on submit when no `uri` is provided. */
+  "submit",
+  /** Emitted whenever form validity changes. */
+  "valid",
+  /** Emitted when a custom renderer dispatches a form event. */
+  "events",
+  /** Emitted when validation errors change. */
+  "errors",
+  /** Emitted when the user cancels editing an existing record. */
+  "cancel"
+];
+class FormStore {
+  constructor(uri) {
+    this.uri = uri;
+  }
+  async delete(data) {
+    return toolsVue.useApi().delete(`${this.uri}/${data.id}`).then(() => {
+      ui.NotificationService.success("Data deleted");
+    }).catch((error2) => {
+      console.error(error2);
+      ui.NotificationService.error("Error deleting data");
+    });
+  }
+  async save(id, data) {
+    if (!this.uri) return;
+    const promise2 = id ? toolsVue.useApi().patch(`${this.uri}/${id}`, data) : toolsVue.useApi().post(this.uri, data);
+    return promise2.then((response) => {
+      ui.NotificationService.success("Data saved");
+      return response.data;
+    }).catch((error2) => {
+      console.error(error2);
+      ui.NotificationService.error("Error saving data");
+    });
+  }
+}
+const _hoisted_1$1 = { class: "flex justify-end gap-2 p-2 mt-2 border-t border-gray-300 z-[30] shrink-0" };
 const _hoisted_2 = { class: "flex justify-end gap-2" };
 const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
-  __name: "form-with-actions.component",
-  props: {
-    ...FormWithActionsProperties,
-    modelValue: { type: Object, default: () => ({}) }
-  },
+  __name: "FormWithActions",
+  props: FormWithActionsProperties,
   emits: FormWithActionsEmits,
   setup(__props, { emit: __emit }) {
     const properties = __props;
     const emits = __emit;
+    const formRef = vue.ref();
     const formData = vue.ref(properties.modelValue);
     const initialFormData = vue.ref(structuredClone(vue.toRaw(properties.modelValue)));
     const recordId = vue.ref(properties.modelValue?.id ?? null);
     const valid = vue.ref(false);
-    const submitted = vue.ref(false);
     vue.watch(
       () => properties.modelValue,
-      (newValue, oldValue) => {
+      (newValue) => {
         if (newValue === formData.value) return;
         recordId.value = newValue?.id ?? null;
         initialFormData.value = structuredClone(vue.toRaw(newValue));
@@ -8204,13 +8572,11 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
       emits("update:modelValue", data);
     };
     const save = () => {
-      submitted.value = true;
-      if (!valid.value) {
-        return;
-      }
+      formRef.value?.markSubmitted();
+      if (!valid.value) return;
       if (store.value) {
-        store.value.save(recordId.value, formData.value).then(() => {
-          emits("success");
+        store.value.save(recordId.value, formData.value).then((response) => {
+          emits("success", response);
         });
       } else {
         emits("submit", formData.value);
@@ -8218,28 +8584,31 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
     };
     const clear = () => {
       formData.value = { id: null };
-      submitted.value = false;
       emits("update:modelValue", formData.value);
     };
     const cancel = () => {
       formData.value = structuredClone(vue.toRaw(initialFormData.value));
-      submitted.value = false;
       emits("update:modelValue", formData.value);
       emits("cancel");
     };
-    const onValid = (v) => {
-      submitted.value = false;
-      valid.value = v;
-      emits("valid", v);
-    };
     const title = vue.computed(() => {
       if (!properties.updateTitle) return properties.createTitle;
       return recordId.value ? properties.updateTitle : properties.createTitle;
     });
+    const onErrors = (errors) => {
+      emits("errors", errors);
+      valid.value = lodashEs.isEmpty(errors);
+    };
+    vue.watch(valid, (newValid, oldValid) => {
+      if (newValid !== oldValid) {
+        emits("valid", newValid);
+      }
+    });
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createBlock(vue.unref(ui.Collapse), {
         title: title.value,
-        "height-full": _ctx.fullHeight
+        "height-full": _ctx.fullHeight,
+        scrollable: true
       }, {
         default: vue.withCtx(() => [
           vue.createElementVNode("div", {
@@ -8250,24 +8619,19 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
             }, [
               vue.createVNode(_sfc_main$2, {
                 id: `form_${_ctx.id}`,
+                ref_key: "formRef",
+                ref: formRef,
                 "form-data": formData.value,
                 schema: _ctx.schema,
                 "ui-schema": _ctx.uiSchema,
+                "error-mode": _ctx.errorMode,
                 onChange: updateValue,
-                onValid: _cache[0] || (_cache[0] = ($event) => onValid($event)),
                 onSubmit: save,
-                onErrors: _cache[1] || (_cache[1] = ($event) => emits("errors", $event)),
-                onEvents: _cache[2] || (_cache[2] = ($event) => emits("events", $event))
-              }, null, 8, ["id", "form-data", "schema", "ui-schema"])
+                onErrors,
+                onEvents: _cache[0] || (_cache[0] = ($event) => emits("events", $event))
+              }, null, 8, ["id", "form-data", "schema", "ui-schema", "error-mode"])
             ], 2),
-            vue.createElementVNode("div", _hoisted_1, [
-              vue.createElementVNode("div", null, [
-                !valid.value && submitted.value ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Alert), {
-                  key: 0,
-                  message: "The form is not valid",
-                  type: "error"
-                })) : vue.createCommentVNode("", true)
-              ]),
+            vue.createElementVNode("div", _hoisted_1$1, [
               vue.createElementVNode("div", _hoisted_2, [
                 vue.renderSlot(_ctx.$slots, "actions"),
                 recordId.value ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
@@ -8276,7 +8640,7 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
                   outline: true,
                   onClick: cancel
                 }, {
-                  default: vue.withCtx(() => [..._cache[3] || (_cache[3] = [
+                  default: vue.withCtx(() => [..._cache[1] || (_cache[1] = [
                     vue.createTextVNode(" Cancel ", -1)
                   ])]),
                   _: 1
@@ -8286,7 +8650,7 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
                   outline: true,
                   onClick: clear
                 }, {
-                  default: vue.withCtx(() => [..._cache[4] || (_cache[4] = [
+                  default: vue.withCtx(() => [..._cache[2] || (_cache[2] = [
                     vue.createTextVNode(" Clear ", -1)
                   ])]),
                   _: 1
@@ -8294,10 +8658,10 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
                 vue.createVNode(vue.unref(ui.Btn), {
                   "aria-label": "Save",
                   color: vue.unref(ui.Color).primary,
-                  disabled: submitted.value,
+                  disabled: !valid.value,
                   onClick: save
                 }, {
-                  default: vue.withCtx(() => [..._cache[5] || (_cache[5] = [
+                  default: vue.withCtx(() => [..._cache[3] || (_cache[3] = [
                     vue.createTextVNode(" Save ", -1)
                   ])]),
                   _: 1
@@ -8311,214 +8675,173 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
+const FormWithTableProperties = {
+  /** Unique identifier used to namespace the inner table element. */
+  id: { type: String, required: true },
+  /** Heading displayed above the table. */
+  tableTitle: { type: String, required: true },
+  /** Title shown in the modal when creating a new record. */
+  createTitle: { type: String, required: true },
+  /** Title shown in the modal when editing a record. Falls back to `createTitle` when omitted. */
+  updateTitle: { type: String },
+  /** Override URI used to fetch table data. Defaults to `uri` when omitted. */
+  dataUri: { type: String },
+  /** Custom row actions rendered in the table. */
+  tableActions: { type: Array },
+  /** JSON Forms layout for the create/edit modal form. */
+  form: { type: Object },
+  /** JSON Forms layout for the table. */
+  table: { type: Object },
+  /** JSON Forms layout for the table filter. */
+  filter: { type: Object },
+  /** REST endpoint used by `FormStore` for CRUD operations. */
+  uri: { type: String },
+  /** Default data pre-filled when creating a new record. */
+  initialData: { type: Object, default: () => ({}) },
+  /** When validation errors are shown in the modal form. */
+  errorMode: {
+    type: String,
+    default: "onBlur"
+  }
+};
+const FormWithTableEmits = [
+  /** Emitted when a row is selected for editing (listener-based routing). */
+  "editData",
+  /** Emitted after a record is saved through the modal. */
+  "save",
+  /** Emitted after a record is deleted. */
+  "delete",
+  /** Emitted when a custom renderer dispatches a form event. */
+  "events",
+  /** Emitted when a custom edit handler is registered. */
+  "custom:edit",
+  /** Emitted when a custom create handler is registered. */
+  "custom:create"
+];
+const _hoisted_1 = { class: "flex justify-between items-center mb-2" };
 const _sfc_main = /* @__PURE__ */ vue.defineComponent({
-  __name: "form-modal",
-  props: /* @__PURE__ */ vue.mergeModels({
-    modalTitle: {},
-    saveLabel: { default: "save" },
-    cancelLabel: { default: "cancel" },
-    schema: {},
-    uiSchema: {},
-    modalSize: { default: "md" },
-    onClose: {},
-    onEvents: {},
-    data: {}
-  }, {
-    "modelValue": {},
-    "modelModifiers": {}
-  }),
-  emits: /* @__PURE__ */ vue.mergeModels(["closeModal", "events"], ["update:modelValue"]),
+  __name: "FormWithTable",
+  props: FormWithTableProperties,
+  emits: FormWithTableEmits,
   setup(__props, { emit: __emit }) {
     const properties = __props;
-    const id = `modal_${Math.floor(Math.random() * 1e3)}`;
-    const valid = vue.ref(false);
-    const hasBeenValid = vue.ref(false);
-    const formData = vue.useModel(__props, "modelValue");
-    const emits = __emit;
-    if (properties.data) {
-      formData.value = properties.data;
-    }
-    const onValid = (v) => {
-      valid.value = v;
-      if (v) hasBeenValid.value = true;
+    const emit = __emit;
+    const reload = vue.ref(0);
+    const resolvedForm = vue.computed(() => properties.form);
+    const resolvedTable = vue.computed(() => properties.table);
+    const resolvedFilter = vue.computed(() => properties.filter);
+    const resolvedUri = vue.computed(() => properties.uri);
+    let store = new FormStore(resolvedUri.value ?? "");
+    vue.watch(resolvedUri, (uri) => {
+      store = new FormStore(uri ?? "");
+    });
+    const hasEdit = ui.hasCustomEventListener("editData");
+    const customEdit = ui.hasCustomEventListener("custom:edit");
+    const customCreate = ui.hasCustomEventListener("custom:create");
+    const edit = (data) => {
+      if (customEdit) {
+        emit("custom:edit", data);
+        return;
+      }
+      if (hasEdit) {
+        emit("editData", data);
+        return;
+      }
+      openModal(data);
     };
-    const onCancel = () => {
-      formData.value = {};
-      emits("closeModal", null);
+    const create = () => {
+      if (customCreate) {
+        emit("custom:create");
+        return;
+      }
+      openModal();
     };
-    const onChange = (data) => {
-      formData.value = data;
+    const deleteFn = (data) => {
+      ui.ModalService.showConfirm({
+        title: "Delete record",
+        message: "Are you sure to delete, the data will be lost?",
+        onClose: (result) => {
+          if (result.confirmed) {
+            store.delete(data).then(() => {
+              reload.value = Date.now();
+              emit("delete", data);
+            });
+          }
+        }
+      });
     };
-    const onSubmit = () => {
-      if (!valid.value) return;
-      emits("closeModal", { data: formData.value, valid: valid.value });
+    const openModal = (formData) => {
+      if (!resolvedForm.value) return;
+      const isUpdate = !!formData?.id;
+      JsonFormModalService.openModal({
+        schema: resolvedForm.value.schema,
+        uiSchema: resolvedForm.value.uiSchema,
+        modalSize: resolvedForm.value.modalSize,
+        initialData: formData ?? properties.initialData,
+        modalTitle: (isUpdate ? properties.updateTitle ?? properties.createTitle : properties.createTitle) ?? "",
+        onClose: (result) => {
+          if (result && result.valid) {
+            store.save(formData?.id, result.data).then(() => {
+              reload.value = Date.now();
+              emit("save", { id: formData?.id, data: result.data });
+            });
+          }
+        },
+        onEvents: (payload) => emit("events", payload)
+      });
     };
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createBlock(vue.unref(ui.Modal), vue.mergeProps(properties, {
-        open: true,
-        "disable-close": false,
-        width: __props.modalSize,
-        onCloseModal: onCancel
-      }), {
-        content: vue.withCtx(() => [
-          vue.renderSlot(_ctx.$slots, "content-before"),
-          vue.createVNode(_sfc_main$2, {
-            id: `modal-${id}`,
-            modelValue: formData.value,
-            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => formData.value = $event),
-            schema: __props.schema,
-            "ui-schema": __props.uiSchema,
-            onValid: _cache[1] || (_cache[1] = ($event) => onValid($event)),
-            onChange,
-            onEvents: _cache[2] || (_cache[2] = ($event) => emits("events", $event))
-          }, null, 8, ["id", "modelValue", "schema", "ui-schema"]),
-          vue.renderSlot(_ctx.$slots, "content-after")
-        ]),
-        actions: vue.withCtx(() => [
-          vue.createVNode(vue.unref(ui.Btn), {
-            color: vue.unref(ui.Color).secondary,
-            outline: true,
-            "aria-label": "Cancel",
-            onClick: onCancel
-          }, {
-            default: vue.withCtx(() => [..._cache[3] || (_cache[3] = [
-              vue.createTextVNode(" Cancel ", -1)
-            ])]),
-            _: 1
-          }, 8, ["color"]),
-          vue.createVNode(vue.unref(ui.Btn), {
-            disabled: !hasBeenValid.value,
-            "aria-label": "Save",
-            onClick: onSubmit
-          }, {
-            default: vue.withCtx(() => [..._cache[4] || (_cache[4] = [
-              vue.createTextVNode(" Save ", -1)
-            ])]),
-            _: 1
-          }, 8, ["disabled"])
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createElementVNode("div", _hoisted_1, [
+          vue.createElementVNode("h1", null, vue.toDisplayString(_ctx.tableTitle), 1),
+          vue.createElementVNode("div", null, [
+            vue.createVNode(vue.unref(ui.Btn), {
+              icon: vue.unref(ui.IconEnum).Plus,
+              outline: true,
+              onClick: create
+            }, {
+              default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
+                vue.createTextVNode(" Add new record ", -1)
+              ])]),
+              _: 1
+            }, 8, ["icon"])
+          ])
         ]),
-        _: 3
-      }, 16, ["width"]);
+        resolvedTable.value ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Card), { key: 0 }, {
+          default: vue.withCtx(() => [
+            resolvedUri.value ? (vue.openBlock(), vue.createBlock(vue.unref(_sfc_main$g), {
+              key: 0,
+              id: `form_table_${_ctx.id}`,
+              "ui-schema": resolvedTable.value.uiSchema,
+              schema: resolvedTable.value.schema,
+              "filter-ui-schema": resolvedFilter.value?.uiSchema,
+              "filter-schema": resolvedFilter.value?.schema,
+              uri: _ctx.dataUri ?? resolvedUri.value,
+              reload: reload.value,
+              actions: _ctx.tableActions,
+              onEdit: edit,
+              onDelete: deleteFn
+            }, null, 8, ["id", "ui-schema", "schema", "filter-ui-schema", "filter-schema", "uri", "reload", "actions"])) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        })) : vue.createCommentVNode("", true)
+      ], 64);
     };
   }
 });
-class FormModalService {
-  static openModal({
-    initialData,
-    modalTitle,
-    schema,
-    uiSchema,
-    modalSize,
-    onClose,
-    onEvents
-  }) {
-    ui.ModalService.openModal({
-      component: _sfc_main,
-      props: {
-        schema,
-        uiSchema,
-        modalSize,
-        data: initialData ?? {},
-        modalTitle,
-        onClose,
-        onEvents
-      }
-    });
-  }
-}
-const createRepository = (formSchemaModel, httpRequest, options = {}) => {
-  const notificationEntity = options.notification?.entityType || "entity";
-  const notificationStore = options.notification?.notification ?? null;
-  const getDataUri = (...suffix) => {
-    return [formSchemaModel.uri, ...suffix].join("/");
-  };
-  const handleSuccess = (message) => {
-    notificationStore?.success(message);
-  };
-  const handleError = (error2, message) => {
-    console.error(error2);
-    notificationStore?.error(message);
-    throw new Error(error2);
-  };
-  const create = (object2, options2) => {
-    return httpRequest.post(getDataUri(), object2, options2).then((response) => {
-      handleSuccess(`Created ${notificationEntity}`);
-      return response.data;
-    }).catch((response) => {
-      handleError(response, `Failed to create ${notificationEntity}`);
-    });
-  };
-  const patch = (id, object2, options2) => {
-    return httpRequest.patch(getDataUri(id), object2, options2).then((response) => {
-      handleSuccess(`Saved ${notificationEntity}`);
-      return response.data;
-    }).catch((response) => {
-      handleError(response, `Failed to save ${notificationEntity}`);
-    });
-  };
-  const get = (id, options2) => {
-    return httpRequest.get(getDataUri(id), options2).then((response) => {
-      return response.data;
-    }).catch((response) => {
-      handleError(response, `Failed to load data`);
-    });
-  };
-  const _delete = (id, options2) => {
-    return httpRequest.delete(getDataUri(id), options2).then((response) => {
-      handleSuccess(`${notificationEntity} deleted`);
-      return response;
-    }).catch((response) => {
-      handleError(response, `Failed to delete ${notificationEntity}`);
-    });
-  };
-  const createMulti = (objects, options2) => {
-    return Promise.all(
-      objects.map((object2) => httpRequest.post(getDataUri(), object2, options2))
-    ).then((response) => {
-      handleSuccess(`Created ${notificationEntity}`);
-      return response.data;
-    }).catch((response) => {
-      handleError(response, `Failed to save ${notificationEntity}`);
-    });
-  };
-  return { create, patch, createMulti, delete: _delete, get };
-};
-exports.ArrayRenderer = _sfc_main$a;
-exports.AutocompleteControlRenderer = _sfc_main$j;
-exports.BooleanControlRenderer = _sfc_main$i;
-exports.FormComponent = _sfc_main$2;
-exports.FormComponentEmits = FormComponentEmits;
-exports.FormComponentProperties = FormComponentProperties;
-exports.FormModal = _sfc_main;
-exports.FormModalService = FormModalService;
-exports.FormStore = FormStore;
-exports.FormWithActions = _sfc_main$1;
-exports.FormWithActionsEmits = FormWithActionsEmits;
-exports.FormWithActionsProperties = FormWithActionsProperties;
-exports.FormWithTableComponent = _sfc_main$3;
-exports.FormWithTableEmits = FormWithTableEmits;
-exports.FormWithTableProperties = FormWithTableProperties;
-exports.IntegerControlRenderer = _sfc_main$h;
-exports.MultiSelectControlRender = _sfc_main$f;
-exports.NumberControlRenderer = _sfc_main$e;
-exports.SelectControlRender = _sfc_main$d;
-exports.StringControlRenderer = _sfc_main$c;
-exports.TableComponent = _sfc_main$4;
+exports.FormModalEmits = FormModalEmits;
+exports.FormModalProperties = FormModalProperties;
+exports.JsonForm = _sfc_main$2;
+exports.JsonFormModal = _sfc_main$d;
+exports.JsonFormModalService = JsonFormModalService;
+exports.JsonFormWithActions = _sfc_main$1;
+exports.JsonFormWithTable = _sfc_main;
+exports.TableComponent = _sfc_main$g;
 exports.TableComponentEmits = TableComponentEmits;
 exports.TableComponentProperties = TableComponentProperties;
-exports.arrayRenderers = arrayRenderers;
-exports.controlRenderers = controlRenderers;
 exports.createRepository = createRepository;
-exports.isArrayRenderer = isArrayRenderer;
-exports.isAutoCompleteControl = isAutoCompleteControl;
-exports.isBooleanControl = isBooleanControl;
-exports.isCustomControl = isCustomControl;
-exports.isMarkdownControl = isMarkdownControl;
-exports.isMultiselectControl = isMultiselectControl;
-exports.isSelectControl = isSelectControl;
-exports.isStringFormat = isStringFormat;
-exports.isTextAreaControl = isTextAreaControl;
-exports.layoutRenderers = layoutRenderers;
-exports.markdownControlRenderer = _sfc_main$g;
+exports.formatError = formatError;
 exports.provideFormEvents = provideFormEvents;
+exports.registerZodErrorMap = registerZodErrorMap;
 exports.useFormEvents = useFormEvents;
+exports.veeRenderers = customRenderes;