@signaltree/ng-forms 7.3.0 → 7.3.2

package/README.md

@@ -77,11 +77,14 @@ class CheckoutComponent {
 ### form() alone (no ng-forms needed)
 
 ```typescript
+import { signalTree, form } from '@signaltree/core';
+import { email } from '@signaltree/ng-forms';
+
 // Pure signal forms - works without Angular forms module
 const tree = signalTree({
   login: form({
     initial: { email: '', password: '' },
-    validators: { email: validators.email() },
+    validators: { email: email() },
   }),
 });
 
@@ -137,9 +140,9 @@ pnpm add @signaltree/core @signaltree/ng-forms
 
 ```typescript
 import { Component } from '@angular/core';
-import { createFormTree, validators } from '@signaltree/ng-forms';
+import { createFormTree, required, email } from '@signaltree/ng-forms';
 
-interface ProfileForm {
+interface ProfileForm extends Record<string, unknown> {
   name: string;
   email: string;
   marketing: boolean;
@@ -182,9 +185,9 @@ export class ProfileFormComponent {
       persistKey: 'profile-form',
       storage: this.storage,
       fieldConfigs: {
-        name: { validators: validators.required('Name is required') },
+        name: { validators: [required('Name is required')] },
         email: {
-          validators: [validators.required(), validators.email()],
+          validators: [required(), email()],
           debounceMs: 150,
         },
       },
@@ -256,8 +259,8 @@ class CheckoutComponent {
   }, {
     persistKey: 'checkout-draft',
     fieldConfigs: {
-      'shipping.zip': { validators: validators.zipCode() },
-      'payment.card': { validators: validators.creditCard(), debounceMs: 300 }
+      'shipping.zip': { validators: [(v) => /^\d{5}$/.test(String(v)) ? null : 'Invalid ZIP'] },
+      'payment.card': { validators: [(v) => /^\d{13,19}$/.test(String(v)) ? null : 'Invalid card'], debounceMs: 300 }
     }
   });
 
@@ -287,7 +290,7 @@ const checkout = createFormTree(initialState, {
   },
   fieldConfigs: {
     'payment.card.number': { debounceMs: 200 },
-    'preferences.*': { validators: validators.required() },
+    'preferences.*': { validators: [required()] },
   },
   conditionals: [
     {
@@ -399,7 +402,7 @@ Use `SignalValueDirective` to keep standalone signals and `ngModel` fields align
 ### Before (deprecated)
 
 ```typescript
-import { createFormTree } from '@signaltree/ng-forms';
+import { createFormTree, email } from '@signaltree/ng-forms';
 
 const form = createFormTree(
   {
@@ -407,7 +410,7 @@ const form = createFormTree(
     email: '',
   },
   {
-    validators: { email: validators.email() },
+    validators: { email: email() },
     persistKey: 'profile-form',
   }
 );
@@ -421,12 +424,12 @@ form.form; // FormGroup
 
 ```typescript
 import { signalTree, form } from '@signaltree/core';
-import { formBridge } from '@signaltree/ng-forms';
+import { formBridge, email } from '@signaltree/ng-forms';
 
 const tree = signalTree({
   profile: form({
     initial: { name: '', email: '' },
-    validators: { email: validators.email() },
+    validators: { email: email() },
     persist: 'profile-form',
   }),
 }).with(formBridge());

package/dist/audit/audit.js

@@ -0,0 +1,74 @@
+import { getChanges } from '../get-changes.js';
+
+function createAuditTracker(tree, auditLog, config = {}) {
+  const {
+    getMetadata,
+    includePreviousValues = false,
+    filter,
+    maxEntries = 0
+  } = config;
+  let previousState = structuredClone(tree());
+  let isTracking = true;
+  const handleChange = () => {
+    if (!isTracking) return;
+    const currentState = tree();
+    const changes = getChanges(previousState, currentState);
+    if (Object.keys(changes).length > 0) {
+      if (filter && !filter(changes)) {
+        previousState = structuredClone(currentState);
+        return;
+      }
+      const entry = {
+        timestamp: Date.now(),
+        changes,
+        metadata: getMetadata?.()
+      };
+      if (includePreviousValues) {
+        const prevValues = {};
+        for (const key of Object.keys(changes)) {
+          prevValues[key] = previousState[key];
+        }
+        entry.previousValues = prevValues;
+      }
+      auditLog.push(entry);
+      if (maxEntries > 0 && auditLog.length > maxEntries) {
+        auditLog.splice(0, auditLog.length - maxEntries);
+      }
+    }
+    previousState = structuredClone(currentState);
+  };
+  let unsubscribe;
+  let pollingId;
+  if ('subscribe' in tree && typeof tree.subscribe === 'function') {
+    try {
+      unsubscribe = tree.subscribe(handleChange);
+    } catch {
+      pollingId = setInterval(handleChange, 100);
+    }
+  } else {
+    pollingId = setInterval(handleChange, 100);
+  }
+  return () => {
+    isTracking = false;
+    if (unsubscribe) {
+      unsubscribe();
+    }
+    if (pollingId) {
+      clearInterval(pollingId);
+    }
+  };
+}
+function createAuditCallback(auditLog, getMetadata) {
+  return (previousState, currentState) => {
+    const changes = getChanges(previousState, currentState);
+    if (Object.keys(changes).length > 0) {
+      auditLog.push({
+        timestamp: Date.now(),
+        changes,
+        metadata: getMetadata?.()
+      });
+    }
+  };
+}
+
+export { createAuditCallback, createAuditTracker };

package/dist/audit/index.js

@@ -0,0 +1 @@
+export { createAuditCallback, createAuditTracker } from './audit.js';

package/dist/constants.js

@@ -0,0 +1,6 @@
+const SHARED_DEFAULTS = Object.freeze({
+  PATH_CACHE_SIZE: 1000
+});
+const DEFAULT_PATH_CACHE_SIZE = SHARED_DEFAULTS.PATH_CACHE_SIZE;
+
+export { DEFAULT_PATH_CACHE_SIZE, SHARED_DEFAULTS };

package/dist/core/async-validators.js

@@ -0,0 +1,24 @@
+import { isObservable, firstValueFrom } from 'rxjs';
+
+function unique(checkFn, message = 'Already exists') {
+  return async value => {
+    if (!value) return null;
+    const exists = await checkFn(value);
+    return exists ? message : null;
+  };
+}
+function debounce(validator, delayMs) {
+  let timeoutId;
+  return async value => {
+    return new Promise(resolve => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(async () => {
+        const maybeAsync = validator(value);
+        const result = isObservable(maybeAsync) ? await firstValueFrom(maybeAsync) : await maybeAsync;
+        resolve(result);
+      }, delayMs);
+    });
+  };
+}
+
+export { debounce, unique };