@signaltree/ng-forms 3.0.2 → 4.0.2

package/index.d.ts

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
-import { WritableSignal, Signal, OnInit, EventEmitter } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { WritableSignal, DestroyRef, Signal, OnInit, EventEmitter } from '@angular/core';
+import { FormGroup, AbstractControl, FormArray, ControlValueAccessor } from '@angular/forms';
 import { Observable } from 'rxjs';
-import { TreeNode, SignalTree, TreeConfig, Middleware } from '@signaltree/core';
+import { TreeConfig, TreeNode, SignalTree } from '@signaltree/core';
 
-type AsyncValidatorFn<T> = (value: T) => Observable<string | null> | Promise<string | null>;
+type FormTreeAsyncValidatorFn<T> = (value: T) => Observable<string | null> | Promise<string | null>;
 type EnhancedArraySignal<T> = WritableSignal<T[]> & {
     push: (item: T) => void;
     removeAt: (index: number) => void;
@@ -13,9 +13,31 @@ type EnhancedArraySignal<T> = WritableSignal<T[]> & {
     move: (from: number, to: number) => void;
     clear: () => void;
 };
-type FormTree<T extends Record<string, unknown>> = {
+type FieldValidator = (value: unknown) => string | null;
+interface FieldConfig {
+    debounceMs?: number;
+    validators?: Record<string, FieldValidator> | FieldValidator[];
+    asyncValidators?: Record<string, FormTreeAsyncValidatorFn<unknown>> | Array<FormTreeAsyncValidatorFn<unknown>>;
+}
+interface ConditionalField<T> {
+    when: (values: T) => boolean;
+    fields: string[];
+}
+interface FormTreeOptions<T extends Record<string, unknown>> extends TreeConfig {
+    validators?: SyncValidatorMap;
+    asyncValidators?: AsyncValidatorMap;
+    destroyRef?: DestroyRef;
+    fieldConfigs?: Record<string, FieldConfig>;
+    conditionals?: Array<ConditionalField<T>>;
+    persistKey?: string;
+    storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+    persistDebounceMs?: number;
+    validationBatchMs?: number;
+}
+type FormTree$1<T extends Record<string, unknown>> = {
     state: TreeNode<T>;
     $: TreeNode<T>;
+    form: FormGroup;
     errors: WritableSignal<Record<string, string>>;
     asyncErrors: WritableSignal<Record<string, string>>;
     touched: WritableSignal<Record<string, boolean>>;
@@ -37,11 +59,20 @@ type FormTree<T extends Record<string, unknown>> = {
     fieldErrors: Record<string, Signal<string | undefined>>;
     fieldAsyncErrors: Record<string, Signal<string | undefined>>;
     values: SignalTree<T>;
+    destroy(): void;
 };
-declare function createFormTree<T extends Record<string, unknown>>(initialValues: T, config?: {
-    validators?: Record<string, (value: unknown) => string | null>;
-    asyncValidators?: Record<string, AsyncValidatorFn<unknown>>;
-} & TreeConfig): FormTree<T>;
+declare class FormValidationError extends Error {
+    readonly errors: Record<string, string>;
+    readonly asyncErrors: Record<string, string>;
+    constructor(errors: Record<string, string>, asyncErrors: Record<string, string>);
+}
+type SyncValidatorMap = Record<string, (value: unknown) => string | null>;
+type AsyncValidatorMap = Record<string, FormTreeAsyncValidatorFn<unknown>>;
+declare function createFormTree<T extends Record<string, unknown>>(initialValues: T, config?: FormTreeOptions<T>): FormTree$1<T>;
+declare function createVirtualFormArray<T>(items: T[], visibleRange: {
+    start: number;
+    end: number;
+}, controlFactory?: (value: T, index: number) => AbstractControl): FormArray;
 declare class SignalValueDirective implements ControlValueAccessor, OnInit {
     signalTreeSignalValue: WritableSignal<unknown>;
     signalTreeSignalValueChange: EventEmitter<unknown>;
@@ -59,27 +90,39 @@ declare class SignalValueDirective implements ControlValueAccessor, OnInit {
     static ɵfac: i0.ɵɵFactoryDeclaration<SignalValueDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<SignalValueDirective, "[signalTreeSignalValue]", never, { "signalTreeSignalValue": { "alias": "signalTreeSignalValue"; "required": false; }; }, { "signalTreeSignalValueChange": "signalTreeSignalValueChange"; }, never, never, true, never>;
 }
-declare const validators: {
-    required: (message?: string) => (value: unknown) => string | null;
-    email: (message?: string) => (value: unknown) => string | null;
-    minLength: (min: number) => (value: unknown) => string | null;
-    pattern: (regex: RegExp, message?: string) => (value: unknown) => string | null;
-};
-declare const asyncValidators: {
-    unique: (checkFn: (value: unknown) => Promise<boolean>, message?: string) => (value: unknown) => Promise<string | null>;
-};
-declare function toObservable<T>(signal: Signal<T>): Observable<T>;
-interface AuditEntry<T = unknown> {
-    timestamp: number;
-    changes: Partial<T>;
-    metadata?: {
-        userId?: string;
-        source?: string;
-        description?: string;
-    };
-}
-declare function createAuditMiddleware<T>(auditLog: AuditEntry<T>[], getMetadata?: () => AuditEntry<T>['metadata']): Middleware<T>;
 declare const SIGNAL_FORM_DIRECTIVES: (typeof SignalValueDirective)[];
 
-export { SIGNAL_FORM_DIRECTIVES, SignalValueDirective, asyncValidators, createAuditMiddleware, createFormTree, toObservable, validators };
-export type { AsyncValidatorFn, AuditEntry, EnhancedArraySignal, FormTree };
+declare function required(message?: string): FieldValidator;
+declare function email(message?: string): FieldValidator;
+declare function minLength(min: number, message?: string): FieldValidator;
+declare function maxLength(max: number, message?: string): FieldValidator;
+declare function pattern(regex: RegExp, message?: string): FieldValidator;
+declare function min(min: number, message?: string): FieldValidator;
+declare function max(max: number, message?: string): FieldValidator;
+declare function compose(validators: FieldValidator[]): FieldValidator;
+
+declare function unique(checkFn: (value: unknown) => Promise<boolean>, message?: string): FormTreeAsyncValidatorFn<unknown>;
+declare function debounce(validator: FormTreeAsyncValidatorFn<unknown>, delayMs: number): FormTreeAsyncValidatorFn<unknown>;
+
+interface FormTree<T extends Record<string, unknown>> {
+    form: any;
+    unwrap(): T;
+    destroy(): void;
+    setValues(values: Partial<T>): void;
+}
+interface FormHistory<T> {
+    past: T[];
+    present: T;
+    future: T[];
+}
+declare function withFormHistory<T extends Record<string, unknown>>(formTree: FormTree<T>, options?: {
+    capacity?: number;
+}): FormTree<T> & {
+    undo: () => void;
+    redo: () => void;
+    clearHistory: () => void;
+    history: Signal<FormHistory<T>>;
+};
+
+export { FormValidationError, SIGNAL_FORM_DIRECTIVES, SignalValueDirective, compose, createFormTree, createVirtualFormArray, debounce, email, max, maxLength, min, minLength, pattern, required, unique, withFormHistory };
+export type { ConditionalField, EnhancedArraySignal, FieldConfig, FieldValidator, FormHistory, FormTree$1 as FormTree, FormTreeAsyncValidatorFn, FormTreeOptions };

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@signaltree/ng-forms",
-  "version": "3.0.2",
+  "version": "4.0.2",
   "description": "Complete Angular forms integration for SignalTree. FormTree creation, custom directives, validators, form state tracking, and RxJS bridge.",
   "peerDependencies": {
-    "@angular/core": "^20.1.0",
-    "@angular/forms": "^20.1.0",
-    "@signaltree/core": "^3.0.0",
+    "@angular/core": "^20.3.0",
+    "@angular/forms": "^20.3.0",
+    "@signaltree/core": "^4.0.0",
     "rxjs": "^7.0.0"
   },
+  "dependencies": {
+    "@signaltree/shared": "workspace:*",
+    "tslib": "^2.3.0"
+  },
   "sideEffects": false,
   "module": "fesm2022/signaltree-ng-forms.mjs",
   "typings": "index.d.ts",
@@ -18,9 +22,18 @@
     ".": {
       "types": "./index.d.ts",
       "default": "./fesm2022/signaltree-ng-forms.mjs"
+    },
+    "./src/audit": {
+      "types": "./src/audit/index.d.ts",
+      "default": "./fesm2022/signaltree-ng-forms-src-audit.mjs"
+    },
+    "./src/rxjs": {
+      "types": "./src/rxjs/index.d.ts",
+      "default": "./fesm2022/signaltree-ng-forms-src-rxjs.mjs"
+    },
+    "./src/history": {
+      "types": "./src/history/index.d.ts",
+      "default": "./fesm2022/signaltree-ng-forms-src-history.mjs"
     }
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
   }
 }

package/src/audit/index.d.ts

@@ -0,0 +1,15 @@
+import { Middleware } from '@signaltree/core';
+
+interface AuditEntry<T = unknown> {
+    timestamp: number;
+    changes: Partial<T>;
+    metadata?: {
+        userId?: string;
+        source?: string;
+        description?: string;
+    };
+}
+declare function createAuditMiddleware<T>(auditLog: AuditEntry<T>[], getMetadata?: () => AuditEntry<T>['metadata']): Middleware<T>;
+
+export { createAuditMiddleware };
+export type { AuditEntry };

package/src/history/index.d.ts

@@ -0,0 +1,24 @@
+import { Signal } from '@angular/core';
+
+interface FormTree<T extends Record<string, unknown>> {
+    form: any;
+    unwrap(): T;
+    destroy(): void;
+    setValues(values: Partial<T>): void;
+}
+interface FormHistory<T> {
+    past: T[];
+    present: T;
+    future: T[];
+}
+declare function withFormHistory<T extends Record<string, unknown>>(formTree: FormTree<T>, options?: {
+    capacity?: number;
+}): FormTree<T> & {
+    undo: () => void;
+    redo: () => void;
+    clearHistory: () => void;
+    history: Signal<FormHistory<T>>;
+};
+
+export { withFormHistory };
+export type { FormHistory };

package/src/rxjs/index.d.ts

@@ -0,0 +1,6 @@
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare function toObservable<T>(signal: Signal<T>): Observable<T>;
+
+export { toObservable };