vlite3 1.4.4 → 1.4.6

package/components/Form/TableRow.vue.js

@@ -0,0 +1,88 @@
+import { defineComponent as x, computed as s, withMemo as h, openBlock as o, createElementBlock as n, normalizeClass as u, createVNode as m, createCommentVNode as l, toDisplayString as y, Fragment as v, renderList as f, createBlock as R, unref as d } from "vue";
+import I from "./FormField.vue.js";
+import C from "../Icon.vue.js";
+import F from "../Button.vue.js";
+import { resolveFieldType as i } from "./utils/form.utils.js";
+const k = {
+  key: 1,
+  class: "w-10 flex-none flex items-center justify-center text-xs text-muted-foreground border-r border-border bg-muted/20"
+}, B = {
+  key: 2,
+  class: "w-10 flex-none flex items-center justify-center border-l border-border bg-muted/20"
+}, z = /* @__PURE__ */ x({
+  __name: "TableRow",
+  props: {
+    row: {},
+    rowIndex: {},
+    fields: {},
+    draggable: { type: Boolean },
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    isUpdate: { type: Boolean },
+    showRowNumbers: { type: Boolean },
+    canRemoveRow: { type: Boolean },
+    helpers: {},
+    onFieldChange: { type: Function },
+    onRemoveRow: { type: Function }
+  },
+  setup(e) {
+    const t = e, c = s(() => t.draggable && !t.disabled && !t.readonly), w = s(() => t.helpers.getRowErrorsHash(t.rowIndex));
+    return (U, a) => h([e.row, e.disabled, e.readonly, e.isUpdate, e.showRowNumbers, e.canRemoveRow, e.draggable, e.rowIndex, w.value], () => (o(), n("div", { class: "flex group bg-white transition-colors min-w-0" }, [
+      c.value ? (o(), n("div", {
+        key: 0,
+        class: u([
+          "w-10 flex-none flex items-center justify-center border-r border-border bg-muted/5 drag-handle transition-colors",
+          e.disabled ? "cursor-not-allowed opacity-50" : "cursor-grab active:cursor-grabbing hover:bg-muted/10 text-muted-foreground hover:text-foreground"
+        ])
+      }, [
+        m(C, {
+          icon: "lucide:grip-vertical",
+          class: "w-4 h-4"
+        })
+      ], 2)) : l("", !0),
+      e.showRowNumbers ? (o(), n("div", k, y(e.rowIndex + 1), 1)) : l("", !0),
+      (o(!0), n(v, null, f(e.fields, (r, b) => (o(), n("div", {
+        key: r.name,
+        class: u(["flex-1 min-w-0 relative", { "border-l border-border": b > 0 }])
+      }, [
+        e.helpers.isFieldVisible(e.rowIndex, r) ? (o(), R(I, {
+          key: 0,
+          field: {
+            ...r,
+            props: {
+              ...d(i)(r, e.helpers.getRowContext(e.rowIndex)) === "multiSelect" ? { showControls: !1, wrap: !1 } : {},
+              ...r.props || {},
+              ...d(i)(r, e.helpers.getRowContext(e.rowIndex)) === "file" || d(i)(r, e.helpers.getRowContext(e.rowIndex)) === "fileUploader" ? { variant: "input" } : {}
+            },
+            label: void 0
+          },
+          value: e.helpers.getFieldValue(e.rowIndex, r.name),
+          values: e.row,
+          errors: e.helpers.errors,
+          error: e.helpers.getFieldError(e.rowIndex, r.name),
+          variant: "transparent",
+          size: "sm",
+          rounded: "none",
+          disabled: e.disabled || e.helpers.isFieldDisabled(e.rowIndex, r),
+          readonly: e.readonly || e.helpers.isFieldReadonly(e.rowIndex, r),
+          isUpdate: e.isUpdate,
+          class: "w-full h-full min-h-[40px]",
+          onChange: (g) => e.onFieldChange(e.rowIndex, r.name, g)
+        }, null, 8, ["field", "value", "values", "errors", "error", "disabled", "readonly", "isUpdate", "onChange"])) : l("", !0)
+      ], 2))), 128)),
+      e.canRemoveRow ? (o(), n("div", B, [
+        m(F, {
+          type: "button",
+          variant: "ghost",
+          size: "xs",
+          icon: "lucide:trash-2",
+          disabled: e.disabled || e.readonly,
+          onClick: a[0] || (a[0] = (r) => e.onRemoveRow(e.rowIndex))
+        }, null, 8, ["disabled"])
+      ])) : l("", !0)
+    ])), a, 1);
+  }
+});
+export {
+  z as default
+};

package/components/Form/TableRow.vue2.js

@@ -0,0 +1,4 @@
+import f from "./TableRow.vue.js";
+export {
+  f as default
+};

package/components/Form/TableView.vue.d.ts

@@ -0,0 +1,23 @@
+import { IForm, IFormFieldChangePayload } from './types';
+import { CustomFieldRow, RowHelpers } from './rowHelpers';
+interface Props {
+    rows: CustomFieldRow[];
+    schema: IForm[];
+    columnHeaders: string[];
+    visibleSchemaFields: IForm[];
+    draggable: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    isUpdate: boolean;
+    showRowNumbers: boolean;
+    canRemoveRow: boolean;
+    canAddRow: boolean;
+    helpers: RowHelpers;
+    emptyTitle: string;
+    emptyDescription: string;
+    onFieldChange: (rowIndex: number, fieldName: string, payload: IFormFieldChangePayload) => void;
+    onRemoveRow: (index: number) => void;
+    onDragUpdate: (rows: CustomFieldRow[]) => void;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/components/Form/TableView.vue.js

@@ -0,0 +1,88 @@
+import { defineComponent as c, openBlock as o, createElementBlock as t, createCommentVNode as d, Fragment as l, renderList as i, normalizeClass as m, toDisplayString as r, createVNode as u, unref as b, withCtx as w, createBlock as g, createElementVNode as s } from "vue";
+import { VueDraggable as y } from "vue-draggable-plus";
+import h from "./TableRow.vue.js";
+const f = { class: "custom-fields-table border border-border rounded overflow-hidden bg-background min-w-0 max-w-full w-full" }, v = {
+  key: 0,
+  class: "flex border-b border-border bg-muted/50 text-gray-800 text-xs font-semibold uppercase tracking-wider min-w-0"
+}, x = {
+  key: 0,
+  class: "w-10 flex-none p-3 border-r border-border"
+}, R = {
+  key: 1,
+  class: "w-10 flex-none p-3 text-center border-r border-border"
+}, k = {
+  key: 2,
+  class: "w-10 flex-none p-3"
+}, B = {
+  key: 1,
+  class: "flex flex-col items-center justify-center py-6 text-center bg-muted/5"
+}, F = { class: "text-sm font-medium text-foreground" }, V = { class: "text-xs text-muted-foreground mt-1" }, S = /* @__PURE__ */ c({
+  __name: "TableView",
+  props: {
+    rows: {},
+    schema: {},
+    columnHeaders: {},
+    visibleSchemaFields: {},
+    draggable: { type: Boolean },
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    isUpdate: { type: Boolean },
+    showRowNumbers: { type: Boolean },
+    canRemoveRow: { type: Boolean },
+    canAddRow: { type: Boolean },
+    helpers: {},
+    emptyTitle: {},
+    emptyDescription: {},
+    onFieldChange: { type: Function },
+    onRemoveRow: { type: Function },
+    onDragUpdate: { type: Function }
+  },
+  setup(e) {
+    return (C, D) => (o(), t("div", f, [
+      e.columnHeaders.length > 1 ? (o(), t("div", v, [
+        e.draggable && !e.disabled && !e.readonly ? (o(), t("div", x)) : d("", !0),
+        e.showRowNumbers ? (o(), t("div", R, " # ")) : d("", !0),
+        (o(!0), t(l, null, i(e.columnHeaders, (n, a) => (o(), t("div", {
+          key: a,
+          class: m(["flex-1 p-3 min-w-0 truncate", { "border-l border-border": a > 0 }])
+        }, r(n), 3))), 128)),
+        e.canRemoveRow ? (o(), t("div", k)) : d("", !0)
+      ])) : d("", !0),
+      u(b(y), {
+        "model-value": e.rows,
+        "onUpdate:modelValue": e.onDragUpdate,
+        disabled: !e.draggable || e.disabled || e.readonly,
+        animation: 150,
+        handle: ".drag-handle",
+        "ghost-class": "opacity-50",
+        class: "divide-y divide-border min-w-0"
+      }, {
+        default: w(() => [
+          (o(!0), t(l, null, i(e.rows, (n, a) => (o(), g(h, {
+            key: n._id,
+            row: n,
+            "row-index": a,
+            fields: e.visibleSchemaFields,
+            draggable: e.draggable,
+            disabled: e.disabled,
+            readonly: e.readonly,
+            "is-update": e.isUpdate,
+            "show-row-numbers": e.showRowNumbers,
+            "can-remove-row": e.canRemoveRow,
+            helpers: e.helpers,
+            "on-field-change": e.onFieldChange,
+            "on-remove-row": e.onRemoveRow
+          }, null, 8, ["row", "row-index", "fields", "draggable", "disabled", "readonly", "is-update", "show-row-numbers", "can-remove-row", "helpers", "on-field-change", "on-remove-row"]))), 128))
+        ]),
+        _: 1
+      }, 8, ["model-value", "onUpdate:modelValue", "disabled"]),
+      e.rows.length === 0 ? (o(), t("div", B, [
+        s("p", F, r(e.emptyTitle), 1),
+        s("p", V, r(e.emptyDescription), 1)
+      ])) : d("", !0)
+    ]));
+  }
+});
+export {
+  S as default
+};

package/components/Form/TableView.vue2.js

@@ -0,0 +1,4 @@
+import f from "./TableView.vue.js";
+export {
+  f as default
+};

package/components/Form/composables/useCustomFieldRows.d.ts

@@ -0,0 +1,52 @@
+import { ComputedRef, ShallowRef } from 'vue';
+import { IForm, IFormFieldChangePayload } from '../types';
+export type CustomFieldRow = Record<string, any> & {
+    _id: string;
+};
+/**
+ * Getters for each reactive prop the composable needs to read. The pattern
+ * is the same one useFileProcessing uses: we receive a function for each
+ * prop rather than the value, so the composable's `watch`es and `computed`s
+ * can read the current value at evaluation time. If we captured the values
+ * by snapshot, the `watch` source `() => options.modelValue` would always
+ * evaluate to the same value and never fire on parent updates.
+ */
+export interface UseCustomFieldRowsGetters {
+    /** Schema for creating empty rows */
+    schema: () => IForm[];
+    /** Two-way bound value (clean — without _id) */
+    modelValue: () => Record<string, any>[];
+    /** Field name in the parent form (used for nested value resolution) */
+    name: () => string | undefined;
+    /** Full form values for `updateValues` context */
+    values: () => Record<string, any> | undefined;
+    isUpdate: () => boolean;
+    disabled: () => boolean;
+    readonly: () => boolean;
+    minRows: () => number;
+    maxRows: () => number;
+}
+export interface UseCustomFieldRowsReturn {
+    /** Rows with internal `_id` for stable v-for keys */
+    rows: ShallowRef<CustomFieldRow[]>;
+    canAddRow: ComputedRef<boolean>;
+    canRemoveRow: ComputedRef<boolean>;
+    getFieldValue: (rowIndex: number, fieldName: string) => any;
+    addRow: () => void;
+    removeRow: (index: number) => void;
+    handleFieldChange: (rowIndex: number, fieldName: string, payload: IFormFieldChangePayload) => Promise<void>;
+    handleDragUpdate: (newRows: CustomFieldRow[]) => void;
+}
+/**
+ * Owns the row state and the add/remove/change/drag operations for the
+ * CustomFields repeater.
+ *
+ * Two-way bound `modelValue` is the public surface (clean rows, no `_id`).
+ * Internally we use a `shallowRef` of rows augmented with `_id` for stable
+ * v-for keys and accordion toggling. The watch on `modelValue` reconciles
+ * external updates while preserving the `_id` of rows that are still present.
+ */
+export declare const useCustomFieldRows: (get: UseCustomFieldRowsGetters, emit: {
+    (e: "update:modelValue", value: Record<string, any>[]): void;
+    (e: "change", value: Record<string, any>[]): void;
+}) => UseCustomFieldRowsReturn;

package/components/Form/composables/useCustomFieldRows.js

@@ -0,0 +1,77 @@
+import { shallowRef as y, watch as b, computed as f } from "vue";
+import { setNestedValue as C } from "../utils/form.utils.js";
+const v = () => `row_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`, E = (l, c) => {
+  const o = y([]), p = () => {
+    const e = {};
+    for (const a of l.schema()) {
+      const s = typeof a.value == "function" ? a.value() : a.value;
+      let t = null;
+      (a.props?.multiple || a.type === "multiSelect" || a.type === "tags") && (t = []), e[a.name] = s ?? t;
+    }
+    return { ...e, _id: v() };
+  }, w = (e) => e.map(({ _id: a, ...s }) => s), u = (e) => {
+    const a = w(e);
+    c("update:modelValue", a), c("change", a);
+  };
+  b(
+    () => l.modelValue(),
+    (e) => {
+      Array.isArray(e) ? o.value = e.map((a, s) => {
+        const t = o.value[s];
+        return {
+          ...a,
+          _id: t?._id || v()
+        };
+      }) : o.value = [];
+    },
+    { immediate: !0, deep: !0 }
+  );
+  const h = f(() => !(l.disabled() || l.readonly() || l.maxRows() && o.value.length >= l.maxRows())), R = f(() => l.disabled() || l.readonly() ? !1 : o.value.length > l.minRows());
+  return {
+    rows: o,
+    canAddRow: h,
+    canRemoveRow: R,
+    getFieldValue: (e, a) => o.value[e]?.[a],
+    addRow: () => {
+      if (l.disabled() || l.readonly() || l.maxRows() && o.value.length >= l.maxRows()) return;
+      const e = [...o.value, p()];
+      o.value = e, u(e);
+    },
+    removeRow: (e) => {
+      if (l.disabled() || l.readonly() || o.value.length <= l.minRows()) return;
+      const a = [...o.value];
+      a.splice(e, 1), o.value = a, u(a);
+    },
+    handleFieldChange: async (e, a, s) => {
+      const t = [...o.value];
+      t[e] = {
+        ...t[e],
+        [a]: s.value
+      };
+      const r = l.schema().find((n) => n.name === a);
+      if (r && r.updateValues)
+        try {
+          const n = t[e], V = l.values() || {}, m = l.name();
+          let d = { ...V };
+          m && (d = C(d, m, t));
+          const i = await r.updateValues({
+            value: s.value,
+            values: n,
+            globalValues: d,
+            data: s.data,
+            isUpdate: l.isUpdate()
+          });
+          i && typeof i == "object" && (t[e] = { ...t[e], ...i });
+        } catch (n) {
+          console.error(`[CustomFields] Error in updateValues for ${a}:`, n);
+        }
+      o.value = t, u(t);
+    },
+    handleDragUpdate: (e) => {
+      o.value = e, u(e);
+    }
+  };
+};
+export {
+  E as useCustomFieldRows
+};

package/components/Form/index.d.ts

@@ -1,7 +1,7 @@
 export { default as Form } from './Form.vue';
 export { default as FormField } from './FormField.vue';
 export { default as FormFields } from './FormFields.vue';
-export { default as CustomFields } from './CustomFields.vue';
+export { default as CustomFields } from './index.vue';
 export { default as FormSkeleton } from './FormSkeleton.vue';
 export * from './types';
 export { useForm } from './composables/useForm';

package/components/Form/{CustomFields.vue.d.ts → index.vue.d.ts}

@@ -18,11 +18,11 @@ interface Props {
     label?: string;
     labelI18n?: string;
     showRowNumbers?: boolean;
-    /** All form values for context */
     values?: Record<string, any>;
-    /** Form Validation errors passed down */
     errors?: Record<string, string>;
     isUpdate?: boolean;
+    layout?: 'table' | 'accordion';
+    accordionTitleKey?: string;
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     change: (value: Record<string, any>[]) => any;
@@ -36,13 +36,16 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     rounded: InputRounded;
     readonly: boolean;
     disabled: boolean;
+    layout: "table" | "accordion";
     isUpdate: boolean;
     modelValue: Record<string, any>[];
     draggable: boolean;
+    errors: Record<string, string>;
+    showRowNumbers: boolean;
+    accordionTitleKey: string;
     headers: string[];
     minRows: number;
+    maxRows: number;
     addButtonText: string;
-    showRowNumbers: boolean;
-    errors: Record<string, string>;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/components/Form/index.vue.js

@@ -0,0 +1,7 @@
+import o from "./index.vue2.js";
+/* empty css           */
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const r = /* @__PURE__ */ t(o, [["__scopeId", "data-v-27f884e3"]]);
+export {
+  r as default
+};

package/components/Form/index.vue2.js

@@ -0,0 +1,141 @@
+import { defineComponent as b, computed as d, openBlock as n, createElementBlock as g, createElementVNode as R, createBlock as r, withCtx as x, createTextVNode as k, toDisplayString as I, createCommentVNode as w, unref as t } from "vue";
+import B from "./TableView.vue.js";
+import C from "./AccordionView.vue.js";
+import F from "../Label.vue.js";
+import U from "../Button.vue.js";
+import { useCustomFieldRows as N } from "./composables/useCustomFieldRows.js";
+import { createRowHelpers as T } from "./rowHelpers.js";
+import { $t as s } from "../../utils/i18n.js";
+const V = { class: "custom-fields-wrapper min-w-0 w-full" }, D = { class: "flex justify-between items-center mb-2" }, O = /* @__PURE__ */ b({
+  name: "CustomFields",
+  __name: "index",
+  props: {
+    name: {},
+    modelValue: { default: () => [] },
+    schema: {},
+    headers: { default: () => [] },
+    variant: { default: "outline" },
+    size: { default: "md" },
+    rounded: { default: "md" },
+    disabled: { type: Boolean, default: !1 },
+    readonly: { type: Boolean, default: !1 },
+    draggable: { type: Boolean, default: !1 },
+    minRows: { default: 0 },
+    maxRows: { default: 0 },
+    addButtonText: { default: "Add Row" },
+    textI18n: {},
+    label: {},
+    labelI18n: {},
+    showRowNumbers: { type: Boolean, default: !1 },
+    values: {},
+    errors: { default: () => ({}) },
+    isUpdate: { type: Boolean, default: !1 },
+    layout: { default: "table" },
+    accordionTitleKey: { default: void 0 }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(a, { emit: v }) {
+    const e = a, p = v, i = d(() => e.labelI18n ? s(e.labelI18n) : e.label), m = d(() => {
+      const o = s("vlite.customFields.emptyTitle");
+      return o !== "vlite.customFields.emptyTitle" ? o : "No items added";
+    }), u = d(() => {
+      const o = s("vlite.customFields.emptyDescription");
+      return o !== "vlite.customFields.emptyDescription" ? o : "Add a new item to get started";
+    }), l = N(
+      {
+        // Getters (not snapshots) — see the long-form note in the composable
+        // file. The `watch(() => options.modelValue, ...)` source must
+        // evaluate to a fresh value on each tick so it fires when the parent
+        // updates `modelValue` (e.g. via a Form-level reset or external
+        // values load).
+        schema: () => e.schema,
+        modelValue: () => e.modelValue,
+        name: () => e.name,
+        values: () => e.values,
+        isUpdate: () => e.isUpdate,
+        disabled: () => e.disabled,
+        readonly: () => e.readonly,
+        minRows: () => e.minRows,
+        maxRows: () => e.maxRows
+      },
+      p
+    ), c = d(() => e.headers && e.headers.length > 0 ? e.headers : e.schema.map((o) => o.labelI18n ? s(o.labelI18n) : typeof o.label == "string" ? o.label : o.name)), h = d(() => e.schema.slice(0, c.value.length)), f = d(
+      () => T({
+        rows: l.rows.value,
+        schema: e.schema,
+        name: e.name,
+        values: e.values,
+        isUpdate: e.isUpdate,
+        errors: e.errors
+      })
+    ), y = d(() => e.labelI18n ? s(e.labelI18n) : e.label ? e.label : "Item");
+    return (o, z) => (n(), g("div", V, [
+      R("div", D, [
+        i.value ? (n(), r(F, {
+          key: 0,
+          class: "text-sm font-medium text-foreground"
+        }, {
+          default: x(() => [
+            k(I(i.value), 1)
+          ]),
+          _: 1
+        })) : w("", !0),
+        a.readonly ? w("", !0) : (n(), r(U, {
+          key: 1,
+          type: "button",
+          variant: "outline",
+          size: "xs",
+          rounded: "full",
+          "as-icon": "",
+          icon: "lucide:plus",
+          disabled: !t(l).canAddRow.value,
+          onClick: t(l).addRow
+        }, null, 8, ["disabled", "onClick"]))
+      ]),
+      a.layout === "table" ? (n(), r(B, {
+        key: 0,
+        rows: t(l).rows.value,
+        schema: e.schema,
+        "column-headers": c.value,
+        "visible-schema-fields": h.value,
+        draggable: a.draggable,
+        disabled: a.disabled,
+        readonly: a.readonly,
+        "is-update": a.isUpdate,
+        "show-row-numbers": a.showRowNumbers,
+        "can-remove-row": t(l).canRemoveRow.value,
+        "can-add-row": t(l).canAddRow.value,
+        helpers: f.value,
+        "empty-title": m.value,
+        "empty-description": u.value,
+        "on-field-change": t(l).handleFieldChange,
+        "on-remove-row": t(l).removeRow,
+        "on-drag-update": t(l).handleDragUpdate
+      }, null, 8, ["rows", "schema", "column-headers", "visible-schema-fields", "draggable", "disabled", "readonly", "is-update", "show-row-numbers", "can-remove-row", "can-add-row", "helpers", "empty-title", "empty-description", "on-field-change", "on-remove-row", "on-drag-update"])) : (n(), r(C, {
+        key: 1,
+        rows: t(l).rows.value,
+        schema: e.schema,
+        draggable: a.draggable,
+        disabled: a.disabled,
+        readonly: a.readonly,
+        "is-update": a.isUpdate,
+        variant: a.variant,
+        size: a.size,
+        rounded: a.rounded,
+        "can-remove-row": t(l).canRemoveRow.value,
+        "can-add-row": t(l).canAddRow.value,
+        helpers: f.value,
+        "accordion-title-key": a.accordionTitleKey,
+        "item-name": y.value,
+        "empty-title": m.value,
+        "empty-description": u.value,
+        "on-field-change": t(l).handleFieldChange,
+        "on-remove-row": t(l).removeRow,
+        "on-drag-update": t(l).handleDragUpdate
+      }, null, 8, ["rows", "schema", "draggable", "disabled", "readonly", "is-update", "variant", "size", "rounded", "can-remove-row", "can-add-row", "helpers", "accordion-title-key", "item-name", "empty-title", "empty-description", "on-field-change", "on-remove-row", "on-drag-update"]))
+    ]));
+  }
+});
+export {
+  O as default
+};

package/components/Form/rowHelpers.d.ts

@@ -0,0 +1,45 @@
+import { IForm } from './types';
+import { CustomFieldRow } from './composables/useCustomFieldRows';
+import { Component } from 'vue';
+export type { CustomFieldRow } from './composables/useCustomFieldRows';
+export interface RowContext {
+    values: Record<string, any>;
+    globalValues: Record<string, any>;
+    isUpdate: boolean;
+}
+export interface RowHelpers {
+    /** All form errors keyed by dot-path (e.g. "team.0.name") */
+    errors: Record<string, string>;
+    /** Lookup a row's cell value by row index + field name. */
+    getFieldValue: (rowIndex: number, fieldName: string) => any;
+    /** Build the form-context object for a row (used by `when`, `updateValues`, etc.). */
+    getRowContext: (rowIndex: number) => RowContext;
+    /** Resolved type string (for dynamic-type schemas). */
+    getResolvedType: (field: IForm, rowIndex: number) => string | Component | undefined;
+    /** Whether the field should render at all in this row. */
+    isFieldVisible: (rowIndex: number, field: IForm) => boolean;
+    /** Whether the field is disabled (schema disabled OR props disabled). */
+    isFieldDisabled: (rowIndex: number, field: IForm) => boolean;
+    /** Whether the field is readonly (schema readonly OR props readonly). */
+    isFieldReadonly: (rowIndex: number, field: IForm) => boolean;
+    /** A short hash of all error messages for the row (used in v-memo). */
+    getRowErrorsHash: (rowIndex: number) => string;
+    /** Look up the per-cell error message for this row. */
+    getFieldError: (rowIndex: number, fieldName: string) => string;
+    /** Whether this row has any errors at all. */
+    hasRowErrors: (rowIndex: number) => boolean;
+}
+export declare const createRowHelpers: (params: {
+    rows: CustomFieldRow[];
+    schema: IForm[];
+    name?: string;
+    values?: Record<string, any>;
+    isUpdate: boolean;
+    errors: Record<string, string>;
+}) => RowHelpers;
+/**
+ * Render a label that may be a string or a Vue Component. Components are
+ * marked raw to skip the reactivity proxy — they're typically inline
+ * presentational components from the schema author.
+ */
+export declare const renderLabel: (label: string | Component | undefined) => string | Component | undefined;

package/components/Form/rowHelpers.js

@@ -0,0 +1,40 @@
+import { evaluateConditional as l, resolveFieldType as h, setNestedValue as m } from "./utils/form.utils.js";
+import { markRaw as y } from "vue";
+const x = (s) => {
+  const { rows: u, name: i, values: c, isUpdate: d, errors: o } = s, p = (r, e) => u[r]?.[e], n = (r) => {
+    let e = { ...c || {} };
+    return i && (e = m(e, i, u)), {
+      values: u[r] || {},
+      globalValues: e,
+      isUpdate: d
+    };
+  }, f = (r, e) => h(r, n(e)), w = (r, e) => l(e.disabled, n(r)), g = (r, e) => l(e.readonly, n(r)), R = (r, e) => e.when ? l(e.when, n(r)) : !0, a = (r) => i ? `${i}.${r}.` : null;
+  return {
+    errors: o,
+    getFieldValue: p,
+    getRowContext: n,
+    getResolvedType: f,
+    isFieldVisible: R,
+    isFieldDisabled: w,
+    isFieldReadonly: g,
+    getRowErrorsHash: (r) => {
+      const e = a(r);
+      return e ? Object.keys(o).filter((t) => t.startsWith(e)).map((t) => o[t]).join(",") : "";
+    },
+    getFieldError: (r, e) => {
+      const t = a(r);
+      return t && o[`${t}${e}`] || "";
+    },
+    hasRowErrors: (r) => {
+      const e = a(r);
+      return e ? Object.keys(o).some((t) => t.startsWith(e)) : !1;
+    }
+  };
+}, $ = (s) => {
+  if (s)
+    return typeof s != "string" ? y(s) : s;
+};
+export {
+  x as createRowHelpers,
+  $ as renderLabel
+};

package/components/Form/types.d.ts

@@ -83,6 +83,9 @@ export interface IFormCustomFieldsProps {
     schema: IForm[];
     headers?: string[];
     draggable?: boolean;
+    layout?: 'table' | 'accordion';
+    accordionTitleKey?: string;
+    addButtonText?: string;
 }
 /**
  * Layout for grouped schemas (schema: IForm[][]).

package/components/IconPicker.vue.d.ts

@@ -21,12 +21,12 @@ declare function __VLS_template(): {
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     onSelect: (value: string, svg: string) => any;
-    onClose: () => any;
     onTrigger: () => any;
+    onClose: () => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
     onOnSelect?: (value: string, svg: string) => any;
-    onOnClose?: () => any;
     onOnTrigger?: () => any;
+    onOnClose?: () => any;
 }>, {
     value: string;
     position: TooltTipPlacement;

package/components/Modal.vue.d.ts

@@ -13,6 +13,7 @@ interface Props {
     headerClass?: string;
     footerClass?: string;
     body?: Component;
+    styles?: any;
     bodyProps?: Record<string, any>;
 }
 declare function __VLS_template(): {
@@ -46,6 +47,7 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {},
     maxWidth: string;
     closeOutside: boolean;
     backdrop: boolean;
+    styles: any;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     modalRef: HTMLDivElement;
 }, any>;