vlite3 0.1.0 → 0.1.2

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

@@ -0,0 +1,48 @@
+import { Ref, ComputedRef } from 'vue';
+import { IForm, IFormSubmitPayload } from '../types';
+export interface UseFormOptions {
+    schema: IForm[] | IForm[][];
+    values?: Record<string, any>;
+    isUpdate?: boolean;
+    onSubmit?: (payload: IFormSubmitPayload) => void | Promise<void>;
+}
+export interface UseFormReturn {
+    /** Current form values */
+    formValues: Ref<Record<string, any>>;
+    /** Validation errors by field name */
+    errors: Ref<Record<string, string>>;
+    /** Whether form is currently submitting */
+    isSubmitting: Ref<boolean>;
+    /** Whether form has been modified */
+    isDirty: Ref<boolean>;
+    /** Handle field value change */
+    handleFieldChange: (name: string, value: any, data?: any) => void;
+    /** Validate a single field */
+    validateField: (field: IForm) => string;
+    /** Validate all fields */
+    validateAll: () => boolean;
+    /** Check if field is visible */
+    isFieldVisible: (field: IForm) => boolean;
+    /** Check if field is disabled */
+    isFieldDisabled: (field: IForm) => boolean;
+    /** Check if field is readonly */
+    isFieldReadonly: (field: IForm) => boolean;
+    /** Get field value (supports nested paths) */
+    getFieldValue: (name: string) => any;
+    /** Get field error */
+    getFieldError: (name: string) => string;
+    /** Set field error manually */
+    setFieldError: (name: string, error: string) => void;
+    /** Clear all errors */
+    clearErrors: () => void;
+    /** Reset form to initial values */
+    resetForm: () => void;
+    /** Handle form submission */
+    handleSubmit: () => Promise<void>;
+    /** Flattened schema for iteration */
+    flatSchema: ComputedRef<IForm[]>;
+}
+/**
+ * Main form composable for managing form state, validation, and submission
+ */
+export declare function useForm(options: UseFormOptions): UseFormReturn;

package/components/Form/composables/useForm.js

@@ -0,0 +1,109 @@
+import { ref as u, computed as $, watch as k } from "vue";
+import { initializeFormValues as j, deepClone as c, getNestedValue as N, evaluateConditional as y, setNestedValue as h, collectFileFields as B, filterNullCustomFields as G } from "../utils/form.utils.js";
+import { useFileUpload as H } from "./useFileUpload.js";
+function X(q) {
+  const { schema: i, values: V, isUpdate: d = !1, onSubmit: b } = q, { handleUploadFile: x, loading: I } = H(), t = u(j(i, V)), r = u({}), v = u(!1), n = u(!1), m = u(c(t.value)), f = $(() => i ? Array.isArray(i[0]) ? i.flat() : i : []);
+  k(
+    () => V,
+    (e) => {
+      e && (t.value = j(i, e), m.value = c(t.value), n.value = !1);
+    },
+    { deep: !0 }
+  );
+  const p = () => ({
+    values: t.value,
+    isUpdate: d
+  }), g = (e) => N(t.value, e), D = (e) => r.value[e] || "", A = (e, l) => {
+    l ? r.value[e] = l : delete r.value[e];
+  }, F = () => {
+    r.value = {};
+  }, S = (e) => e.when ? y(e.when, p()) : !0, w = (e) => y(e.disabled, p()), O = (e) => y(e.readonly, p()), C = (e) => {
+    const l = g(e.name);
+    let a = "";
+    return e.required && (l == null || l === "" || Array.isArray(l) && l.length === 0) && (a = `${e.label || e.name} is required`), !a && e.validation && (a = e.validation({
+      value: l,
+      values: t.value,
+      isUpdate: d
+    })), a ? r.value[e.name] = a : delete r.value[e.name], a;
+  }, E = () => {
+    F();
+    let e = !0;
+    for (const l of f.value) {
+      if (!S(l) || w(l)) continue;
+      C(l) && (e = !1);
+    }
+    return e;
+  }, z = (e, l, a) => {
+    t.value = h(t.value, e, l), n.value = !0, delete r.value[e];
+    const o = f.value.find((s) => s.name === e);
+    if (o?.updateValues) {
+      const s = o.updateValues({
+        values: t.value,
+        data: a,
+        isUpdate: d,
+        updateError: A
+      });
+      s && typeof s == "object" && (t.value = { ...t.value, ...s });
+    }
+  }, L = async () => {
+    const e = c(t.value), l = B(i, e);
+    for (const a of l) {
+      const { name: o, value: s, type: M } = a;
+      if (s instanceof File || s && typeof s == "object" && s.file instanceof File) {
+        const U = await x(s);
+        U && Object.assign(e, h(e, o, U));
+      }
+    }
+    return e;
+  }, R = (e) => {
+    const l = { ...e };
+    for (const a of f.value)
+      if (a.type === "customFields" && a.props?.schema) {
+        const o = N(l, a.name);
+        if (Array.isArray(o)) {
+          const s = G(o, a.props.schema);
+          Object.assign(l, h(l, a.name, s));
+        }
+      }
+    return l;
+  };
+  return {
+    formValues: t,
+    errors: r,
+    isSubmitting: v,
+    isDirty: n,
+    handleFieldChange: z,
+    validateField: C,
+    validateAll: E,
+    isFieldVisible: S,
+    isFieldDisabled: w,
+    isFieldReadonly: O,
+    getFieldValue: g,
+    getFieldError: D,
+    setFieldError: A,
+    clearErrors: F,
+    resetForm: () => {
+      t.value = c(m.value), F(), n.value = !1;
+    },
+    handleSubmit: async () => {
+      if (E()) {
+        v.value = !0;
+        try {
+          let l = await L();
+          l = R(l), b && await b({
+            values: l,
+            isUpdate: d
+          }), n.value = !1, m.value = c(l);
+        } catch (l) {
+          throw console.error("[useForm] Submit error:", l), l;
+        } finally {
+          v.value = !1;
+        }
+      }
+    },
+    flatSchema: f
+  };
+}
+export {
+  X as useForm
+};

package/components/Form/index.d.ts

@@ -0,0 +1,9 @@
+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 * from './types';
+export { useForm } from './composables/useForm';
+export { useFileUpload } from './composables/useFileUpload';
+export type { UseFormOptions, UseFormReturn } from './composables/useForm';
+export type { FileUploadResult } from './composables/useFileUpload';

package/components/Form/types.d.ts

@@ -0,0 +1,167 @@
+import { Component } from 'vue';
+import { IDropdownOptions, InputVariant, InputSize, InputRounded } from '../../types';
+/**
+ * Form field types - maps to corresponding UI components
+ */
+export type IFormFieldType = 'text' | 'email' | 'password' | 'number' | 'file' | 'fileUploader' | 'tel' | 'url' | 'search' | 'date' | 'textarea' | 'time' | 'iconPicker' | 'color' | 'switch' | 'check' | 'customFields' | 'select' | 'multiSelect' | 'avatarUpload' | Component;
+/**
+ * Context passed to conditional functions
+ */
+export interface IFormContext {
+    values: Record<string, any>;
+    isUpdate?: boolean;
+}
+/**
+ * Disabled/Readonly can be boolean or function
+ */
+export type IFormDisabled = boolean | ((context: IFormContext) => boolean);
+/**
+ * Validation function signature
+ */
+export interface IFormValidationContext {
+    value: any;
+    values: Record<string, any>;
+    isUpdate?: boolean;
+}
+export type IFormValidation = (context: IFormValidationContext) => string;
+/**
+ * UpdateValues function signature - allows computed/derived fields
+ */
+export interface IFormUpdateContext {
+    values: Record<string, any>;
+    data?: any;
+    isUpdate?: boolean;
+    updateError?: (name: string, error: string) => void;
+}
+export type IFormUpdateValues = (context: IFormUpdateContext) => Record<string, any>;
+/**
+ * When condition - controls field visibility
+ */
+export type IFormWhen = (context: IFormContext) => boolean;
+/**
+ * CustomFields schema props
+ */
+export interface IFormCustomFieldsProps {
+    schema: IForm[];
+    headers?: string[];
+}
+/**
+ * Main form field interface
+ */
+export interface IForm {
+    /** Field name - supports dot notation for nested paths (e.g., 'pricing.baseAmount') */
+    name: string;
+    /** Field label - can be string or Vue component */
+    label?: string | Component;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Field type - determines which component renders */
+    type?: IFormFieldType;
+    /** Initial/default value - can be static or function */
+    value?: any | (() => any);
+    /** Additional props passed to field component */
+    props?: Record<string, any>;
+    /** CSS class for the field item wrapper */
+    itemClass?: string;
+    /** CSS class for the input element */
+    className?: string;
+    /** Left icon (for inputs) */
+    icon?: string;
+    /** Right icon (for inputs) */
+    iconRight?: string;
+    /** Mark field as required */
+    required?: boolean;
+    /** Disabled state - boolean or conditional function */
+    disabled?: IFormDisabled;
+    /** Readonly state - boolean or conditional function */
+    readonly?: IFormDisabled;
+    /** Left addon text */
+    addonLeft?: string;
+    /** Right addon text */
+    addonRight?: string;
+    /** Options for select/multiSelect/dropdown fields */
+    options?: IDropdownOptions;
+    /** Validation function - returns error message or empty string */
+    validation?: IFormValidation;
+    /** UpdateValues - called when field changes, returns new values object */
+    updateValues?: IFormUpdateValues;
+    /** When condition - shows/hides field based on form state */
+    when?: IFormWhen;
+    /** Mark as sensitive (e.g., for masking) */
+    isSensitiveField?: boolean;
+    /** Min value for number inputs */
+    min?: number;
+    /** Max value for number inputs */
+    max?: number;
+    /** i18n keys */
+    labelI8n?: string;
+    placeholderI8n?: string;
+}
+/**
+ * Timeline step for multi-step forms
+ */
+export interface IFormStep {
+    id: number | string;
+    title: string;
+    icon?: string;
+    description?: string;
+}
+/**
+ * Form component props
+ */
+export interface IFormProps {
+    /** Schema - single array or grouped arrays */
+    schema: IForm[] | IForm[][];
+    /** Initial/bound values */
+    values?: Record<string, any>;
+    /** Input variant applied to all fields */
+    variant?: InputVariant;
+    /** Input size applied to all fields */
+    size?: InputSize;
+    /** Input rounded applied to all fields */
+    rounded?: InputRounded;
+    /** Loading state during submit */
+    loading?: boolean;
+    /** Show/hide default footer with submit button */
+    footer?: boolean;
+    /** Grid columns (number or tailwind class) */
+    columns?: number | string;
+    /** Headings for grouped schemas */
+    groupsHeadings?: string[];
+    /** Descriptions for grouped schemas */
+    groupHeadingsDescription?: string[];
+    /** Timeline steps for multi-step form mode */
+    tabs?: IFormStep[];
+    /** Submit button text */
+    submitText?: string;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Show cancel button */
+    showCancel?: boolean;
+    /** Whether this is an update operation */
+    isUpdate?: boolean;
+    /** Custom class for form element */
+    class?: string;
+    /** Custom class for the grid layout (overrides columns) */
+    gridClass?: string;
+    /** Custom class for group containers */
+    groupClass?: string;
+    /** Custom class for group/step headers */
+    headerClass?: string;
+    /** Custom class for the footer area */
+    footerClass?: string;
+}
+/**
+ * Form submit payload
+ */
+export interface IFormSubmitPayload {
+    values: Record<string, any>;
+    isUpdate?: boolean;
+}
+/**
+ * Field change payload
+ */
+export interface IFormFieldChangePayload {
+    value: any;
+    data?: any;
+}

package/components/Form/utils/form.utils.d.ts

@@ -0,0 +1,44 @@
+import { IForm, IFormContext, IFormDisabled, IFormWhen } from '../types';
+/**
+ * Get a nested value from an object using dot notation path
+ * @example getNestedValue({ pricing: { amount: 100 } }, 'pricing.amount') => 100
+ */
+export declare function getNestedValue(obj: Record<string, any>, path: string): any;
+/**
+ * Set a nested value in an object using dot notation path (immutable)
+ * @example setNestedValue({ pricing: { amount: 100 } }, 'pricing.discount', 10)
+ * => { pricing: { amount: 100, discount: 10 } }
+ */
+export declare function setNestedValue(obj: Record<string, any>, path: string, value: any): Record<string, any>;
+/**
+ * Initialize form values from schema and optional initial values
+ */
+export declare function initializeFormValues(schema: IForm[] | IForm[][], initialValues?: Record<string, any>): Record<string, any>;
+/**
+ * Evaluate a conditional (disabled/readonly/when) function or boolean
+ */
+export declare function evaluateConditional(condition: IFormDisabled | IFormWhen | undefined, context: IFormContext): boolean;
+/**
+ * Filter out null/empty entries from customFields array value
+ */
+export declare function filterNullCustomFields(value: Record<string, any>[] | undefined, schema: IForm[]): Record<string, any>[];
+/**
+ * Collect file fields from schema that need upload processing
+ */
+export declare function collectFileFields(schema: IForm[] | IForm[][], values: Record<string, any>): Array<{
+    name: string;
+    value: any;
+    type: string;
+}>;
+/**
+ * Deep clone an object
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * Get field key for errors/tracking (handles dot notation)
+ */
+export declare function getFieldKey(name: string): string;
+/**
+ * Check if a value is a Vue component
+ */
+export declare function isComponent(value: any): boolean;

package/components/Form/utils/form.utils.js

@@ -0,0 +1,97 @@
+function u(e, i) {
+  if (!i || !e) return;
+  const n = i.split(".");
+  let f = e;
+  for (const t of n) {
+    if (f == null) return;
+    f = f[t];
+  }
+  return f;
+}
+function m(e, i, n) {
+  if (!i) return e;
+  const f = i.split("."), t = { ...e };
+  let r = t;
+  for (let o = 0; o < f.length - 1; o++) {
+    const a = f[o];
+    Array.isArray(r[a]) ? r[a] = [...r[a]] : r[a] = r[a] ? { ...r[a] } : {}, r = r[a];
+  }
+  return r[f[f.length - 1]] = n, t;
+}
+function v(e, i) {
+  const n = i ? c(i) : {}, f = Array.isArray(e[0]) ? e.flat() : e;
+  for (const t of f) {
+    if (!t.name) continue;
+    if (u(n, t.name) === void 0) {
+      const o = typeof t.value == "function" ? t.value() : t.value;
+      o !== void 0 && Object.assign(n, m(n, t.name, o));
+    }
+  }
+  return n;
+}
+function A(e, i) {
+  return e === void 0 ? !1 : typeof e == "boolean" ? e : typeof e == "function" ? e(i) : !1;
+}
+function g(e, i) {
+  return Array.isArray(e) ? e.filter((n) => n ? !i.every((t) => {
+    const r = n[t.name];
+    return r == null || r === "";
+  }) : !1) : [];
+}
+function h(e, i) {
+  const n = [], f = Array.isArray(e[0]) ? e.flat() : e;
+  for (const t of f) {
+    if (!t.name) continue;
+    const r = t.type;
+    if (r === "file" || r === "avatarUpload" || r === "fileUploader") {
+      const o = u(i, t.name);
+      o && n.push({
+        name: t.name,
+        value: o,
+        type: r
+      });
+    }
+    if (r === "customFields" && t.props?.schema) {
+      const o = u(i, t.name);
+      if (Array.isArray(o)) {
+        const y = t.props.schema.filter(
+          (l) => l.type === "file" || l.type === "avatarUpload" || l.type === "fileUploader"
+        );
+        y.length > 0 && o.forEach((l, d) => {
+          y.forEach((s) => {
+            const p = l?.[s.name];
+            p && n.push({
+              name: `${t.name}.${d}.${s.name}`,
+              value: p,
+              type: s.type
+            });
+          });
+        });
+      }
+    }
+  }
+  return n;
+}
+function c(e) {
+  if (e === null || typeof e != "object") return e;
+  if (e instanceof Date) return new Date(e.getTime());
+  if (e instanceof File) return e;
+  if (Array.isArray(e)) return e.map((n) => c(n));
+  const i = {};
+  for (const n in e)
+    Object.prototype.hasOwnProperty.call(e, n) && (i[n] = c(e[n]));
+  return i;
+}
+function F(e) {
+  return e ? typeof e == "object" && (typeof e.render == "function" || typeof e.setup == "function" || e.__name !== void 0 || e.name !== void 0) : !1;
+}
+export {
+  h as collectFileFields,
+  c as deepClone,
+  A as evaluateConditional,
+  g as filterNullCustomFields,
+  u as getNestedValue,
+  v as initializeFormValues,
+  F as isComponent,
+  m as setNestedValue
+};

package/components/Heatmap/Heatmap.vue.d.ts

@@ -0,0 +1,26 @@
+import { HeatmapProps, HeatmapCell } from './types';
+declare const _default: import('vue').DefineComponent<HeatmapProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "cell-click": (cell: HeatmapCell, event: MouseEvent) => any;
+    "cell-hover": (cell: HeatmapCell, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<HeatmapProps> & Readonly<{
+    "onCell-click"?: (cell: HeatmapCell, event: MouseEvent) => any;
+    "onCell-hover"?: (cell: HeatmapCell, event: MouseEvent) => any;
+}>, {
+    class: string;
+    layout: import('./types').HeatmapLayout;
+    minValue: number;
+    maxValue: number;
+    showLegend: boolean;
+    showLabels: boolean;
+    interactive: boolean;
+    responsive: boolean;
+    minCellSize: number;
+    maxCellSize: number;
+    cellClass: string;
+    emptyCellClass: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    wrapperRef: HTMLDivElement;
+    gridRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/components/Heatmap/Heatmap.vue.js

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