@dynamicforms/vue-forms 0.5.1 → 0.6.1

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
-import { ComputedRef } from 'vue';
 import { DefineComponent } from 'vue';
 import { PublicProps } from 'vue';
 import { Ref } from 'vue';
@@ -9,9 +8,7 @@ export declare class AbortEventHandlingException extends Error {
 }
 
 export declare class Action<T extends ActionValue = ActionValue> extends Field<T> {
-    constructor(guard?: symbol);
     protected init(params?: Partial<IFieldConstructorParams<T>>): void;
-    static create<T extends ActionValue = ActionValue>(params?: Partial<IFieldConstructorParams<T>>): Action<T>;
     get icon(): string | undefined;
     set icon(newValue: string | undefined);
     get label(): string | undefined;
@@ -19,17 +16,16 @@ export declare class Action<T extends ActionValue = ActionValue> extends Field<T
     execute(params: any): void;
 }
 
-declare type ActionExecutor = (field: IField, supr: FieldActionExecute, ...params: any[]) => any;
+declare type ActionExecutor = (field: FieldBase, supr: FieldActionExecute, ...params: any[]) => any;
 
 export declare class ActionsMap extends Map<symbol, FieldActionExecute> {
     private readonly eagerActions;
     private readonly registeredActions;
     register(action: FieldActionBase): void;
-    trigger<T extends FieldActionBase>(ActionClass: {
-        new (...args: any[]): T;
+    trigger<T extends FieldActionBase>(ActionClass: (abstract new (...args: any[]) => T) & {
         classIdentifier: symbol;
-    }, field: IField, ...params: any[]): any;
-    triggerEager(field: IField, ...params: any[]): any;
+    }, field: FieldBase, ...params: any[]): any;
+    triggerEager(field: FieldBase, ...params: any[]): any;
     clone(): ActionsMap;
     cloneWithoutValidators(): ActionsMap;
 }
@@ -54,7 +50,7 @@ declare class CompareTo<T = any> extends Validator {
     private otherField;
     private isValidComparison;
     private unregistered;
-    constructor(otherField: IField, isValidComparison: (myValue: T, otherValue: T) => boolean, message: RenderContentRef);
+    constructor(otherField: FieldBase, isValidComparison: (myValue: T, otherValue: T) => boolean, message: RenderContentRef);
     unregister(): void;
 }
 
@@ -62,7 +58,7 @@ export declare class ConditionalEnabledAction extends ConditionalStatementAction
     constructor(statement: Statement);
 }
 
-declare type ConditionalExecutorFn = (field: IField, currentResult: boolean, previousResult: boolean | undefined) => void;
+declare type ConditionalExecutorFn = (field: FieldBase, currentResult: boolean, previousResult: boolean | undefined) => void;
 
 export declare class ConditionalStatementAction extends ValueChangedAction {
     private lastResult;
@@ -70,7 +66,7 @@ export declare class ConditionalStatementAction extends ValueChangedAction {
     constructor(statement: Statement, executorFn: ConditionalExecutorFn);
     static get classIdentifier(): symbol;
     get eager(): boolean;
-    boundToField(field: IField): void;
+    boundToField(field: FieldBase): void;
 }
 
 export declare class ConditionalValueAction<T> extends ConditionalStatementAction {
@@ -97,67 +93,80 @@ export declare namespace DisplayMode {
     export function isDefined(mode: number | string): boolean;
 }
 
-export declare const EmptyField: Field<unknown>;
+export declare const EmptyField: Field<string>;
 
 export declare class EnabledChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
 }
 
 export declare class EnabledChangingAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => boolean);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => boolean);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): boolean;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): boolean;
 }
 
 export declare class ExecuteAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, params: any) => any);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, params: any) => any);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, params: any): any;
+    execute(field: FieldBase, supr: FieldActionExecute, params: any): any;
 }
 
-export declare class Field<T = any> extends FieldBase {
+export declare class Field<T = any> extends FieldBase<T> {
     protected _value: T;
     protected _touched: boolean;
-    constructor(guard?: symbol);
-    protected init(params?: Partial<IFieldConstructorParams<T>>): void;
+    constructor(params?: Partial<IFieldConstructorParams<T>>);
     /**
-     * Creates a new reactive Field instance.
-     * @param params Initial field parameters
-     * @returns Reactive Field instance
+     * Applies the constructor parameters. It is a hook so that a subclass needing different parameter handling
+     * overrides one method instead of redeclaring the constructor - Action does exactly that.
+     *
+     * It is called from this constructor, so it runs before a subclass's own class field initializers, which
+     * only run once super() returns. An override must therefore work off its parameters alone: members the
+     * subclass initializes read as undefined inside it, and anything it writes to such a member is overwritten
+     * the moment the initializer runs.
      */
-    static create<T = any>(this: new (guard?: symbol) => Field<T>, params?: Partial<IFieldConstructorParams<T>>): InstanceType<typeof this>;
+    protected init(params?: Partial<IFieldConstructorParams<T>>): void;
     get value(): T;
     set value(newValue: T);
     get touched(): boolean;
     set touched(touched: boolean);
-    clone(overrides?: Partial<IField<T>>): this;
+    clone(overrides?: Partial<IFieldConstructorParams<T>>): this;
 }
 
-export declare abstract class FieldActionBase implements IFieldAction {
+export declare abstract class FieldActionBase {
     static get classIdentifier(): symbol;
     get classIdentifier(): symbol;
     private readonly executorFn;
     constructor(executorFn: ActionExecutor);
-    execute(field: IField, supr: IFieldAction['execute'], ...params: any[]): any;
+    execute(field: FieldBase, supr: FieldActionExecute, ...params: any[]): any;
     get eager(): boolean;
-    boundToField(field: IField): void;
+    boundToField(field: FieldBase): void;
     unregister(): void;
 }
 
-export declare type FieldActionExecute<T = any> = (field: IField<T>, ...params: any[]) => any;
+export declare type FieldActionExecute<T = any> = (field: FieldBase<T>, ...params: any[]) => any;
 
-export declare abstract class FieldBase<T = any> implements IField<T> {
+export declare abstract class FieldBase<T = any> {
+    /**
+     * A field is a Vue reactive proxy from construction onwards: the base constructor returns the proxy, and a
+     * derived class's `this` is whatever super() returned, so every subclass constructor, field initializer and
+     * method sees the proxy. Consequence: plain `field.property = value` is tracked, with no wrapper in between.
+     */
+    constructor();
     abstract get value(): T;
     abstract set value(newValue: T);
     abstract get touched(): boolean;
     abstract set touched(touched: boolean);
-    readonly reactiveValue: ComputedRef<T>;
-    abstract clone(overrides?: Partial<IField<T>>): IField<T>;
+    abstract clone(overrides?: Partial<IFieldConstructorParams<T>>): FieldBase<T>;
     originalValue: T;
-    protected validatingCount: number;
-    readonly validating = false;
+    private validatingCount;
+    /** true while at least one asynchronous validator is still running for this field */
+    get validating(): boolean;
+    /** announces the start of one asynchronous validation run; validators pair it with endValidating */
+    beginValidating(): void;
+    /** announces the end of one asynchronous validation run */
+    endValidating(): void;
     protected _valid: boolean;
     errors: ValidationError[];
     parent?: Group;
@@ -169,17 +178,51 @@ export declare abstract class FieldBase<T = any> implements IField<T> {
     private _enabled;
     get enabled(): boolean;
     set enabled(newValue: boolean);
+    /**
+     * While true, validate() on this field does nothing at all: it neither recomputes _valid nor emits
+     * ValidChangedAction, and nothing climbs to the parent. A container that walks its members one by one - assigning
+     * them a value, or revalidating them - sets it for the duration of the walk, so a member's upward climb cannot
+     * announce the verdict of a half-applied value or of a half-revalidated set, and clears it in a finally block
+     * followed by its own validate(). That call recomputes over the finished state and emits the net transition, so
+     * the deferral cannot swallow a real change.
+     */
+    protected suppressValidation: boolean;
+    /**
+     * While true, a validity change is still recomputed and still announced on this field, but it is not passed up to
+     * the parent: the climb is only remembered and carried out by flushParentValidityClimb(). A setter that notifies
+     * the parent of the new value itself holds it over the notifying region, so the parent forms its verdict once,
+     * over the finished value, instead of once over the value being replaced and once over the value replacing it.
+     */
+    protected suppressParentValidityClimb: boolean;
+    private parentValidityClimbPending;
+    /** Carries out the climb that a validity change made while suppressParentValidityClimb was held, if there was one. */
+    protected flushParentValidityClimb(): void;
     validate(revalidate?: boolean): void;
     get valid(): boolean;
     get fullValue(): any;
     get isChanged(): boolean;
-    registerAction(action: IFieldAction<T>): this;
-    triggerAction<T2 extends IFieldAction<T>>(actionClass: new (...args: any[]) => T2, ...params: any[]): any;
+    /**
+     * Registers the actions a constructor received in its parameters: registration without the eager trigger,
+     * because a constructor ends with a single this.actions.triggerEager(...) over the finished value, and an
+     * eager action registered here would otherwise also run once per registration, over a half-built field.
+     */
+    protected registerInitialActions(actions: FieldActionBase[]): void;
+    registerAction(action: FieldActionBase): this;
+    triggerAction<T2 extends FieldActionBase>(actionClass: (abstract new (...args: any[]) => T2) & {
+        classIdentifier: symbol;
+    }, ...params: any[]): any;
+    private _validationEpoch;
+    /**
+     * Generation counter of the validators attached to this field. A Validator reads it when a run starts and drops
+     * a result whose epoch no longer matches, so a validation still in flight when clearValidators() is called
+     * cannot push an error onto a field that no longer has the validator that produced it.
+     */
+    get validationEpoch(): number;
     clearValidators(): void;
 }
 
-declare type FieldsToValues<T extends GenericFieldsInterface> = {
-    [K in keyof T]: T[K] extends IField<infer U> ? U : T[K] extends Group<infer G> ? FieldsToValues<G> : any;
+export declare type FieldsToValues<T extends GenericFieldsInterface> = {
+    [K in keyof T]: T[K]['value'];
 };
 
 declare namespace Form {
@@ -210,16 +253,18 @@ declare namespace Form {
         Field,
         NullableField,
         EmptyField,
-        IField,
         IFieldConstructorActionsList,
         IFieldConstructorParams,
         AbortEventHandlingException,
         FieldActionExecute,
-        IFieldAction,
         FieldBase,
         GenericFieldsInterface,
+        FieldsToValues,
+        GroupValue,
+        GroupValueInput,
         Group,
         NullableGroup,
+        ListValue,
         List,
         NullableList,
         Validators,
@@ -253,61 +298,63 @@ declare interface FormsConfig {
     useMarkdownInValidators: boolean;
 }
 
-export declare type GenericFieldsInterface = Record<string, IField>;
+export declare type GenericFieldsInterface = Record<string, FieldBase>;
 
-export declare class Group<T extends GenericFieldsInterface = GenericFieldsInterface> extends FieldBase {
+export declare class Group<T extends GenericFieldsInterface = GenericFieldsInterface> extends FieldBase<GroupValue<T>> {
     private readonly _fields;
     private _value;
-    readonly reactiveValue: ComputedRef<FieldsToValues<T> | null>;
     private suppressNotifyValueChanged;
-    constructor(fields: T, params?: Partial<IFieldConstructorParams>);
+    constructor(fields: T, params?: Partial<IFieldConstructorParams<GroupValueInput<T>>>);
     private addField;
     private static isValidFields;
     static createFromFormData(data: Record<string, any> | null): Group;
     field<K extends keyof T>(fieldName: K): T[K] | null;
     get fields(): T;
-    get value(): FieldsToValues<T> | null;
-    set value(newValue: FieldsToValues<T> | null);
+    get value(): GroupValue<T>;
+    /**
+     * Writes the members that the given value carries, without letting any single member announce the state in
+     * between: the group's own value notification and its own validation are both held back for the duration, so
+     * neither a ValueChangedAction nor a ValidChangedAction reports a verdict over a half-applied value. The
+     * caller decides what to announce once the whole value is in place. Both flags are restored to what they were,
+     * so a caller that is itself holding the group back stays in charge.
+     */
+    private assignMembers;
+    set value(newValue: GroupValueInput<T>);
     get touched(): boolean;
     set touched(touched: boolean);
     get fullValue(): Record<string, any>;
     notifyValueChanged(): void;
     get valid(): boolean;
     validate(revalidate?: boolean): void;
-    clone(overrides?: Partial<IField>): Group<T>;
+    clone(overrides?: Partial<IFieldConstructorParams<GroupValueInput<T>>>): Group<T>;
 }
 
-export declare interface IField<T = any> {
+/** what Group.value reads back: the full field map, or null when no field serializes */
+export declare type GroupValue<T extends GenericFieldsInterface> = FieldsToValues<T> | null;
+
+/** what Group.value and the Group constructor accept: keys left out are simply not assigned */
+export declare type GroupValueInput<T extends GenericFieldsInterface> = Partial<FieldsToValues<T>> | null;
+
+export declare interface IFieldConstructorActionsList {
+    actions?: FieldActionBase[];
+    validators?: FieldActionBase[];
+}
+
+/**
+ * Parameters accepted by field constructors and by clone overrides.
+ *
+ * Only writable members are listed. valid, validating, fullValue and isChanged are getter-only, so assigning
+ * them throws a TypeError. parent and fieldName are set by the container: until a Group or List installs them
+ * as non-configurable accessors, assigning them is silently accepted, which is why the type rejects them.
+ */
+export declare type IFieldConstructorParams<T = any> = {
     value: T;
-    reactiveValue: ComputedRef<T>;
-    fullValue: T;
     originalValue: T;
-    valid: boolean;
-    validating: boolean;
-    errors: ValidationError[];
     enabled: boolean;
     visibility: DisplayMode;
     touched: boolean;
-    parent?: any;
-    fieldName?: string;
-    clone(overrides?: Partial<IField<T>>): IField<T>;
-    registerAction(action: IFieldAction<T>): this;
-    triggerAction<T2 extends IFieldAction<T>>(actionClass: abstract new (...args: any[]) => T2, ...params: any[]): any;
-    validate(revalidate?: boolean): void;
-    clearValidators(): void;
-    isChanged: boolean;
-}
-
-export declare interface IFieldAction<T = any> {
-    execute(field: IField<T>, supr: FieldActionExecute<T>, ...params: any[]): any;
-}
-
-export declare interface IFieldConstructorActionsList<T = any> {
-    actions?: IFieldAction<T>[];
-    validators?: IFieldAction<T>[];
-}
-
-export declare type IFieldConstructorParams<T = any> = IField<T> & IFieldConstructorActionsList<T>;
+    errors: ValidationError[];
+} & IFieldConstructorActionsList;
 
 declare class InAllowedValues<T = any> extends Validator {
     constructor(allowedValues: T[], message?: RenderContentRef);
@@ -326,18 +373,23 @@ declare class LengthInRange<T = any> extends Validator {
     constructor(minLength: number, maxLength: number, message?: RenderContentRef);
 }
 
-export declare class List<T extends GenericFieldsInterface = GenericFieldsInterface> extends FieldBase {
+export declare class List<T extends GenericFieldsInterface = GenericFieldsInterface> extends FieldBase<ListValue> {
     private _value;
     private _itemTemplate?;
     private _previousValue;
-    constructor(itemTemplate?: Group<T>, params?: Partial<IFieldConstructorParams>);
+    constructor(itemTemplate?: Group<T>, params?: Partial<IFieldConstructorParams<ListValue>>);
     private processSetValueItem;
+    /**
+     * Builds the item that fills a gap left by an insert beyond the end of the list: a copy of the item template with
+     * the template's own values, or an empty group when the list has no template.
+     */
+    private createPaddingItem;
     private setValueInternal;
-    get value(): Record<string, any>[] | null;
+    get value(): ListValue;
     set value(newValue: Record<string, any>[]);
     get touched(): boolean;
     set touched(touched: boolean);
-    clone(overrides?: Partial<IField>): List<T>;
+    clone(overrides?: Partial<IFieldConstructorParams<ListValue>>): List<T>;
     notifyValueChanged(): void;
     get valid(): boolean;
     validate(revalidate?: boolean): void;
@@ -350,17 +402,20 @@ export declare class List<T extends GenericFieldsInterface = GenericFieldsInterf
 }
 
 export declare class ListItemAddedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, item: any, index: number) => void);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, item: any, index: number) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, item: any, index: number): void;
+    execute(field: FieldBase, supr: FieldActionExecute, item: any, index: number): void;
 }
 
 export declare class ListItemRemovedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, item: any, index: number) => void);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, item: any, index: number) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, item: any, index: number): void;
+    execute(field: FieldBase, supr: FieldActionExecute, item: any, index: number): void;
 }
 
+/** what List.value reads back: one plain object per item, or null when the list is empty */
+export declare type ListValue = Record<string, any>[] | null;
+
 declare class MaxLength<T = any> extends Validator {
     constructor(maxLength: number, message?: RenderContentRef);
 }
@@ -396,7 +451,7 @@ export declare type NullableGroup = Group | null;
 
 export declare type NullableList = List | null;
 
-export declare type OperandType = any | Statement | IField;
+export declare type OperandType = any | Statement | FieldBase;
 
 /**
  * Operators provides us a functionality for backend to send us complex condition upon which we send
@@ -482,7 +537,7 @@ export declare class Statement {
      * Recursively collects all fields used in this statement and its nested statements
      * @returns A set of all fields used in this statement
      */
-    collectFields(): Set<IField>;
+    collectFields(): Set<FieldBase>;
 }
 
 /**
@@ -523,7 +578,7 @@ export declare class ValidationErrorText extends ValidationError {
     get extraClasses(): ClassTypes;
 }
 
-export declare type ValidationFunction<T = any> = (newValue: T, oldValue: T, field: IField<T>) => ValidationFunctionResult | Promise<ValidationFunctionResult>;
+export declare type ValidationFunction<T = any> = (newValue: T, oldValue: T, field: FieldBase<T>) => ValidationFunctionResult | Promise<ValidationFunctionResult>;
 
 export declare type ValidationFunctionResult = ValidationError[] | null;
 
@@ -533,11 +588,26 @@ export declare type ValidationFunctionResult = ValidationError[] | null;
  */
 export declare class Validator<T = any> extends ValueChangedAction {
     private readonly source;
+    /**
+     * Sequence number of the newest run of this validator, per field. Every execution takes the next number, and a
+     * result is applied only while its number is still the newest one, so a slow run cannot overwrite the verdict of
+     * a faster one that started after it. The key is the field because one validator instance may be registered on
+     * several fields, each with a sequence of its own.
+     */
+    private readonly runs;
     /**
      * Creates a new validator
      * @param validationFn Function that validates the field value and returns errors or null
      */
     constructor(validationFn: ValidationFunction<T>);
+    /**
+     * Returns the error instance this validator owns and may later withdraw: the argument itself when it carries no
+     * ownership stamp or already carries this validator's, a copy of it when it belongs to another validator. The
+     * stamp is not configurable, so an instance one validator owns can never be reassigned to another; the copy is
+     * what makes an error instance shareable between validators, and it keeps the prototype and every own property,
+     * including the non-enumerable ones, so it renders exactly like the instance it was made from.
+     */
+    private claim;
     static get classIdentifier(): symbol;
     get eager(): boolean;
     protected replacePlaceholdersFunction(text: RenderContentRef, replace: Record<string, any>): RenderContentRef;
@@ -563,15 +633,15 @@ export declare namespace Validators {
 }
 
 export declare class ValidChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
 }
 
 export declare class ValueChangedAction<T = any> extends FieldActionBase {
-    constructor(executorFn: (field: IField<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T) => void);
+    constructor(executorFn: (field: FieldBase<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T): void;
+    execute(field: FieldBase<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T): void;
 }
 
 declare class ValueInRange<T = any> extends Validator {
@@ -579,15 +649,15 @@ declare class ValueInRange<T = any> extends Validator {
 }
 
 export declare class VisibilityChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => void);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): void;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): void;
 }
 
 export declare class VisibilityChangingAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => DisplayMode);
+    constructor(executorFn: (field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => DisplayMode);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): DisplayMode;
+    execute(field: FieldBase, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): DisplayMode;
 }
 
 export { }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dynamicforms/vue-forms",
   "private": false,
-  "version": "0.5.1",
+  "version": "0.6.1",
   "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žnik",
@@ -12,17 +12,27 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/dynamicforms-vue-forms.umd.cjs",
-      "import": "./dist/dynamicforms-vue-forms.js"
-    }
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/dynamicforms-vue-forms.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/dynamicforms-vue-forms.umd.cjs"
+      }
+    },
+    "./style.css": "./dist/dynamicforms-vue-forms.css",
+    "./package.json": "./package.json"
   },
   "workspaces": [
     "docs"
   ],
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && node -e \"require('fs').copyFileSync('dist/index.d.ts', 'dist/index.d.cts')\"",
+    "prepack": "npm run build",
     "test": "vitest run --coverage",
     "lint": "eslint src --fix && vue-tsc --noEmit",
+    "lint:ci": "eslint src && vue-tsc --noEmit",
     "docs:dev": "npm run docs:dev -w docs",
     "docs:build": "npm run docs:build -w docs",
     "docs:preview": "npm run docs:preview -w docs"
@@ -43,13 +53,19 @@
   "homepage": "https://docs.velis.si/dynamicforms/vue-forms",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/velis74/dynamicforms-vue-forms.git"
+    "url": "git+https://github.com/dynamicforms/vue-forms.git"
   },
   "bugs": {
-    "url": "https://github.com/velis74/dynamicforms-vue-forms/issues"
+    "url": "https://github.com/dynamicforms/vue-forms/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21"
   },
   "peerDependencies": {
-    "lodash-es": "^4.17.12",
     "vue": "^3.4"
   },
   "devDependencies": {