@dynamicforms/vue-forms 0.18.0 → 1.1.0

package/dist/index.d.ts

@@ -662,6 +662,10 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
      * List of errors. The array handed out is the one the element holds, and a validator writes into it in place,
      * so a transaction that is open takes the element into its record here: a rollback that put back everything
      * except the errors would leave a state the form never held.
+     *
+     * The array and its members are Vue proxies, not the raw instances a validator returned - `field.errors[0] ===
+     * myError` is `false` for the very error that produced it. Unwrapping here would lose the tracked read a
+     * template needs to re-render when a message behind a `Ref` changes; `toRaw()` compares identity instead.
      */
     get errors(): ValidationError[];
     set errors(newValue: ValidationError[]);
@@ -825,6 +829,8 @@ export declare abstract class FieldBase<T = any, X extends object = Extras> {
     /**
      * Records a child's new verdict in this element's tally. The child reports it as it settles, and the commit
      * settles the deepest element first, so the tally a container reads when its own turn comes is finished.
+     * The delta is applied here rather than recomputed by walking the members at commit, which would cost
+     * `O(members)` per container and turn a list fill back into the quadratic walk this tally exists to avoid.
      */
     protected childValidityChanged(nowValid: boolean): void;
     /**
@@ -999,6 +1005,7 @@ declare namespace Form {
         GroupValueInput,
         Group,
         NullableGroup,
+        isEqual,
         ListValue,
         List,
         NullableList,
@@ -1221,6 +1228,16 @@ declare class InAllowedValues<T = any> extends Validator {
 
 export declare function isCallableFunction(msg?: RenderContentRef): msg is RenderContentCallable;
 
+/**
+ * Structural equality that treats a `FieldBase` as what it holds. `isEqual(fieldA, fieldB)` and
+ * `isEqual(list.items, other.items)` compare values the way `isEqual(fieldA.value, fieldB.value)` already does,
+ * without a call site having to unwrap every element by hand.
+ *
+ * Two `FieldBase` operands skip `isEqualWith`'s dispatch and compare `.value` directly — about 40% faster than
+ * routing the same comparison through the customizer, measured comparing two single-field elements.
+ */
+export declare function isEqual(a: unknown, b: unknown): boolean;
+
 /**
  * Type guard to check if content is a custom component definition
  * @param msg - Content to check

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dynamicforms/vue-forms",
   "private": false,
-  "version": "0.18.0",
+  "version": "1.1.0",
   "type": "module",
-  "description": "A lightweight Vue.js library for form state management with built-in validation, conditional logic, nested structures, and a rich event system. UI-agnostic and TypeScript-first.",
-  "author": "Jure Erzno\u017enik",
+  "description": "A Vue.js library for form state management with built-in validation, conditional logic, nested structures, and a rich event system. UI-agnostic and TypeScript-first.",
+  "author": "Jure Erznožnik",
   "files": [
     "dist/*"
   ],
@@ -92,5 +92,9 @@
     "vue-eslint-parser": "^10.4.1",
     "vue-markdown-render": "^2.3.0",
     "vue-tsc": "^2"
+  },
+  "allowScripts": {
+    "@parcel/watcher@2.5.6": true,
+    "unrs-resolver@1.12.2": true
   }
 }

package/readme.md

@@ -1,6 +1,6 @@
 # @dynamicforms/vue-forms
 
-A lightweight, reactive data entry forms library for Vue.js that handles form state management without dictating your
+A reactive data entry forms library for Vue.js that handles form state management without dictating your
 UI components.
 
 ## Introduction
@@ -18,7 +18,6 @@ mechanism applies at every level of a nested form.
 - **Fields that react to each other**: Conditional visibility, enablement and values are declared as statements over other fields, and an action pipeline lets a handler intercept, transform or abort an event.
 - **Reactive & Type-Safe**: Every member of a field, group or list is a tracked read, and a group's value type is inferred from the fields it holds, nested structures included.
 - **Structural serialization**: A group's value is the shape of its fields, and `Group.createFromFormData()` turns a plain object back into a form.
-- **Lightweight**: `vue` (^3.5.2) is the only peer dependency and `lodash-es` the only runtime one.
 
 ## Features
 
@@ -42,7 +41,6 @@ mechanism applies at every level of a nested form.
   as a second type argument, checked by the compiler and read through `extra`
 - **Display modes**: control field visibility with different display modes (Full, Hidden, Invisible, Suppress)
 - **TypeScript support**: full type definitions, and a group's value type inferred from the fields it holds
-- **Lightweight**: `vue` (^3.5.2) is the only peer dependency and `lodash-es` the only runtime one
 
 ## Installation