@ghentcdh/json-forms-vue 1.1.1 → 3.0.0

package/index.js

@@ -1,1892 +1,9 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vue = require("vue");
-const lodashEs = require("lodash-es");
-const jsonFormsCore = require("@ghentcdh/json-forms-core");
-const ui = require("@ghentcdh/ui");
-const core = require("@vueuse/core");
-const vueRouter = require("vue-router");
-const toolsVue = require("@ghentcdh/tools-vue");
-const zod = require("zod");
-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 },
-  /** 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
-  },
-  /** 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 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 form validity changes. */
-  "valid"
-];
-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 removeFilter = (filter) => {
-      formData.value[filter.key] = void 0;
-      emits("changeFilters", formData.value);
-    };
-    return (_ctx, _cache) => {
-      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))
-        ])
-      ]);
-    };
-  }
+var _ghentcdh_crouton_forms_vue = require("@ghentcdh/crouton-forms-vue");
+Object.keys(_ghentcdh_crouton_forms_vue).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _ghentcdh_crouton_forms_vue[k];
+		}
+	});
 });
-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((error) => {
-        console.error(error);
-        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 ?? [];
-    });
-    this.init = (url) => {
-      this.uri.value = url;
-    };
-    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"
-      };
-    });
-    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$7 = {
-  key: 0,
-  class: "mb-2"
-};
-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();
-      }
-    );
-    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,
-      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 onSort = (id) => {
-      store.sort(id);
-    };
-    const sort = vue.computed(() => {
-      return store.sorting.value ?? { orderBy: "", ascending: 1 };
-    });
-    return (_ctx, _cache) => {
-      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 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 = (error, message) => {
-    console.error(error);
-    notificationStore?.error(message);
-    throw new Error(error);
-  };
-  const create = (object, options2) => {
-    return httpRequest.post(getDataUri(), object, options2).then((response) => {
-      handleSuccess(`Created ${notificationEntity}`);
-      return response.data;
-    }).catch((response) => {
-      handleError(response, `Failed to create ${notificationEntity}`);
-    });
-  };
-  const patch = (id, object, options2) => {
-    return httpRequest.patch(getDataUri(id), object, 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((object) => httpRequest.post(getDataUri(), object, options2))
-    ).then((response) => {
-      handleSuccess(`Created ${notificationEntity}`);
-      return response.data;
-    }).catch((response) => {
-      handleError(response, `Failed to save ${notificationEntity}`);
-    });
-  };
-  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(() => {
-    })
-  );
-};
-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 = () => {
-  zod.z.config({
-    customError: (issue) => {
-      if (issue.code === "invalid_type" && issue.received === "undefined") {
-        return { message: "This field is required" };
-      }
-      if (issue.code === "invalid_type" && issue.received === "null") {
-        return { message: "This field is required" };
-      }
-      if (issue.code === "too_small") {
-        const i = issue;
-        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 (issue.code === "too_big") {
-        const i = issue;
-        if (i.type === "string") {
-          return { message: `Must be at most ${i.maximum} characters` };
-        }
-      }
-      return { message: issue.message };
-    }
-  });
-};
-function findRenderer(registry, uischema, schema) {
-  let best = null;
-  for (const entry of registry) {
-    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 registry = 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(registry, 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 = zod.z.enum(["get", "post", "delete", "put", "patch"]);
-const OperationSchema = zod.z.object({
-  uri: zod.z.string(),
-  method: MethodSchema
-});
-const OperationsSchema = zod.z.string().or(OperationSchema);
-const BooleanOperationSchema = zod.z.boolean().or(OperationSchema).optional().default(false);
-const Operations = zod.z.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 = zod.z.object({
-  id: zod.z.string(),
-  uri: zod.z.string(),
-  operations: Operations,
-  schema: zod.z.object({
-    ui: zod.z.any().optional(),
-    data: zod.z.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 config = {};
-  if (options.uri)
-    config = useRemoteOption(options);
-  if (options.resource)
-    config = await useResourceOptions(options);
-  return {
-    fetchOptions: null,
-    labelKey: options.labelKey,
-    valueKey: options.valueKey,
-    enableCreate: options.enableCreate ?? false,
-    form: null,
-    ...config
-  };
-};
-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 } = 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 meta.dirty;
-      case "onSubmit":
-        return submitted.value;
-      case "onBlur":
-      default:
-        return meta.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;
-      }
-      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;
-    }
-    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);
-      }
-    });
-    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"]);
-    };
-  }
-});
-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
-      }
-    });
-  }
-}
-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 config = await useFetchOptions(
-        appliedOptions.value
-      );
-      return config;
-    });
-    const onChange = (val) => {
-      setValue(val);
-      onFieldChange();
-    };
-    const formEvents = useFormEvents();
-    const path = scopeToPath(props.uischema.scope);
-    const setValue = (result) => {
-      if (!result || !fetchOptions.value) {
-        field.setValue(result);
-        return;
-      }
-      const { valueKey, labelKey } = fetchOptions.value;
-      const keys = [valueKey, labelKey].filter(Boolean);
-      if (keys.length === 0) {
-        field.setValue(result);
-        return;
-      }
-      const stripped = lodashEs.pick(result, keys);
-      field.setValue(stripped);
-    };
-    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) => {
-              setValue(res);
-            });
-          }
-        });
-        return;
-      }
-      formEvents.dispatch({
-        event: "create",
-        type: path,
-        data: value.value,
-        onSuccess: setValue
-      });
-    };
-    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);
-    };
-  }
-});
-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"]);
-    };
-  }
-});
-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"]);
-    };
-  }
-});
-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"]);
-    };
-  }
-});
-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"]);
-    };
-  }
-});
-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 _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 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
-  }
-];
-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"]);
-    };
-  }
-});
-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 "));
-    };
-  }
-});
-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 customRenderes = [layoutRenderes, index, arrayRenderers].flat();
-const _hoisted_1$2 = ["id"];
-const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
-  __name: "FormComponent",
-  props: JsonFormComponentProperties,
-  emits: JsonFormComponentEmits,
-  setup(__props, { expose: __expose, emit: __emit }) {
-    registerZodErrorMap();
-    const properties = __props;
-    const emits = __emit;
-    const zodSchema = vue.computed(() => {
-      if (!properties.schema) return void 0;
-      try {
-        const patched = jsonFormsCore.enforceRequiredStringMinLength(properties.schema);
-        return zod.fromJSONSchema(patched);
-      } catch {
-        return void 0;
-      }
-    });
-    const { values, errors, meta, 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,
-      (newData) => {
-        if (!newData) return;
-        if (JSON.stringify(newData) === JSON.stringify(vue.toRaw(values))) return;
-        syncing = true;
-        setValues(newData);
-        vue.nextTick(() => {
-          syncing = false;
-        });
-      },
-      { deep: true }
-    );
-    vue.watch(
-      values,
-      (newValues) => {
-        if (syncing) return;
-        const isValid = meta.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: vue.toRaw(values),
-        valid: meta.value.valid
-      });
-    };
-    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.createVNode(_sfc_main$f, {
-          uischema: _ctx.uiSchema,
-          schema: _ctx.schema
-        }, null, 8, ["uischema", "schema"])
-      ], 40, _hoisted_1$2);
-    };
-  }
-});
-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((error) => {
-      console.error(error);
-      ui.NotificationService.error("Error deleting data");
-    });
-  }
-  async save(id, data) {
-    if (!this.uri) return;
-    const promise = id ? toolsVue.useApi().patch(`${this.uri}/${id}`, data) : toolsVue.useApi().post(this.uri, data);
-    return promise.then((response) => {
-      ui.NotificationService.success("Data saved");
-      return response.data;
-    }).catch((error) => {
-      console.error(error);
-      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: "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);
-    vue.watch(
-      () => properties.modelValue,
-      (newValue) => {
-        if (JSON.stringify(vue.toRaw(newValue)) === JSON.stringify(vue.toRaw(formData.value))) return;
-        recordId.value = newValue?.id ?? null;
-        initialFormData.value = structuredClone(vue.toRaw(newValue));
-        formData.value = newValue;
-      }
-    );
-    const store = vue.computed(
-      () => properties.uri ? new FormStore(properties.uri) : null
-    );
-    const updateValue = (data) => {
-      formData.value = data;
-      emits("update:modelValue", data);
-    };
-    const save = () => {
-      formRef.value?.markSubmitted();
-      if (!valid.value) return;
-      if (store.value) {
-        store.value.save(recordId.value, formData.value).then((response) => {
-          emits("success", response);
-        });
-      } else {
-        emits("submit", formData.value);
-      }
-    };
-    const clear = () => {
-      formData.value = { id: null };
-      emits("update:modelValue", formData.value);
-    };
-    const cancel = () => {
-      formData.value = structuredClone(vue.toRaw(initialFormData.value));
-      emits("update:modelValue", formData.value);
-      emits("cancel");
-    };
-    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,
-        scrollable: true
-      }, {
-        default: vue.withCtx(() => [
-          vue.createElementVNode("div", {
-            class: vue.normalizeClass(["flex flex-col", { "overflow-hidden h-full": _ctx.scrollable }])
-          }, [
-            vue.createElementVNode("div", {
-              class: vue.normalizeClass(["flex-1", { "overflow-y-auto overflow-x-hidden": _ctx.scrollable }])
-            }, [
-              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,
-                onSubmit: save,
-                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$1, [
-              vue.createElementVNode("div", _hoisted_2, [
-                vue.renderSlot(_ctx.$slots, "actions"),
-                recordId.value ? (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
-                  key: 0,
-                  "aria-label": "Cancel",
-                  outline: true,
-                  onClick: cancel
-                }, {
-                  default: vue.withCtx(() => [..._cache[1] || (_cache[1] = [
-                    vue.createTextVNode(" Cancel ", -1)
-                  ])]),
-                  _: 1
-                })) : (vue.openBlock(), vue.createBlock(vue.unref(ui.Btn), {
-                  key: 1,
-                  "aria-label": "Clear",
-                  outline: true,
-                  onClick: clear
-                }, {
-                  default: vue.withCtx(() => [..._cache[2] || (_cache[2] = [
-                    vue.createTextVNode(" Clear ", -1)
-                  ])]),
-                  _: 1
-                })),
-                vue.createVNode(vue.unref(ui.Btn), {
-                  "aria-label": "Save",
-                  color: vue.unref(ui.Color).primary,
-                  disabled: !valid.value,
-                  onClick: save
-                }, {
-                  default: vue.withCtx(() => [..._cache[3] || (_cache[3] = [
-                    vue.createTextVNode(" Save ", -1)
-                  ])]),
-                  _: 1
-                }, 8, ["color", "disabled"])
-              ])
-            ])
-          ], 2)
-        ]),
-        _: 3
-      }, 8, ["title", "height-full"]);
-    };
-  }
-});
-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: "FormWithTable",
-  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 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;
-      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.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"])
-          ])
-        ]),
-        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);
-    };
-  }
-});
-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.createRepository = createRepository;
-exports.formatError = formatError;
-exports.provideFormEvents = provideFormEvents;
-exports.registerZodErrorMap = registerZodErrorMap;
-exports.useFormEvents = useFormEvents;
-exports.veeRenderers = customRenderes;