vlite3 1.4.5 → 1.4.6

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,9 +18,7 @@ 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';
@@ -42,11 +40,12 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     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>;
-    accordionTitleKey: 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/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/Screen/ScreenFilter.vue.js

@@ -19,7 +19,7 @@ import "@vueuse/core";
 import "iconify-icon-picker";
 import "iconify-icon-picker/style.css";
 /* empty css                                 */
-/* empty css                        */
+/* empty css                 */
 /* empty css                                         */
 /* empty css                                    */
 /* empty css                                        */

package/components/ThumbnailSelector/ThumbnailSelector.vue.js

@@ -1,7 +1,7 @@
 import o from "./ThumbnailSelector.vue2.js";
 /* empty css                       */
 import t from "../../_virtual/_plugin-vue_export-helper.js";
-const p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-9fd1363d"]]);
+const p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-470fec5b"]]);
 export {
   p as default
 };

package/components/ThumbnailSelector/ThumbnailSelector.vue2.js

@@ -1,6 +1,6 @@
 import { defineComponent as L, ref as w, watch as k, computed as m, openBlock as i, createElementBlock as d, toDisplayString as p, createCommentVNode as g, createElementVNode as v, createVNode as f, unref as P, withCtx as _, Fragment as V, renderList as F, normalizeClass as S, withModifiers as C, createBlock as y } from "vue";
 import h from "../Icon.vue.js";
-import M from "../FilePicker/FilePicker.vue.js";
+import M from "../FilePicker/index.vue.js";
 import { VueDraggable as O } from "vue-draggable-plus";
 import { $t as z } from "../../utils/i18n.js";
 const q = ["data-testid"], G = {

package/components/index.d.ts

@@ -17,7 +17,7 @@ export { Chip } from './Chip';
 export { ChoiceBox } from './ChoiceBox';
 export { ColorPicker } from './ColorPicker';
 export { default as ConfirmationModal } from './ConfirmationModal.vue';
-export { default as CustomFields } from './Form/CustomFields.vue';
+export { CustomFields } from './Form';
 export { DataList } from './DataList';
 export { List } from './List';
 export { DataTable } from './DataTable';

package/index.js

@@ -9,7 +9,7 @@ import { default as ae } from "./components/Chip/Chip.vue.js";
 import { default as me } from "./components/Form/Form.vue.js";
 import { default as pe } from "./components/Form/FormField.vue.js";
 import { default as ue } from "./components/Form/FormFields.vue.js";
-import { default as xe } from "./components/Form/CustomFields.vue.js";
+import { default as xe } from "./components/Form/index.vue.js";
 import { default as ne } from "./components/Form/FormSkeleton.vue.js";
 import { useForm as Ce } from "./components/Form/composables/useForm.js";
 import { useFileUpload as Te } from "./components/Form/composables/useFileUpload.js";
@@ -80,7 +80,7 @@ import { SCREEN_CONTEXT_KEY as Yt } from "./components/DataTable/types.js";
 import { default as zt } from "./components/Splitter/Splitter.vue.js";
 import { default as Ht } from "./components/Footer/Footer.vue.js";
 import { initializeTheme as Wt, useTheme as Xt } from "./composables/useTheme.js";
-import { default as qt } from "./components/FilePicker/FilePicker.vue.js";
+import { default as qt } from "./components/FilePicker/index.vue.js";
 import { default as Jt } from "./components/Pagination/Pagination.vue.js";
 import { default as er } from "./components/ExportData/ExportData.vue.js";
 import { default as tr } from "./components/ImportData/ImportData.vue.js";

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "description": "A Vue 3 UI component library built with Tailwind CSS.",
   "license": "MIT",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "type": "module",
   "main": "index.js",
   "module": "index.js",