@signaltree/guardrails 5.1.6 → 6.0.1

package/README.md

@@ -22,12 +22,14 @@ npm install --save-dev @signaltree/guardrails
 
 ```typescript
 import { signalTree } from '@signaltree/core';
-import { withGuardrails } from '@signaltree/guardrails';
-
-const tree = signalTree({ count: 0 }).with(withGuardrails({
-  budgets: { maxUpdateTime: 16 },
-  hotPaths: { threshold: 10 },
-}));
+import { guardrails } from '@signaltree/guardrails';
+
+const tree = signalTree({ count: 0 }).with(
+  guardrails({
+    budgets: { maxUpdateTime: 16 },
+    hotPaths: { threshold: 10 },
+  })
+);
 ```
 
 ## Using Factories
@@ -36,10 +38,14 @@ const tree = signalTree({ count: 0 }).with(withGuardrails({
 import { signalTree } from '@signaltree/core';
 import { createFeatureTree } from '@signaltree/guardrails/factories';
 
-const tree = createFeatureTree(signalTree, { data: [] }, {
-  name: 'dashboard',
-  guardrails: true,
-});
+const tree = createFeatureTree(
+  signalTree,
+  { data: [] },
+  {
+    name: 'dashboard',
+    guardrails: true,
+  }
+);
 ```
 
 ## Configuration

package/dist/factories/index.js

@@ -1,5 +1,4 @@
-import { withGuardrails } from '../lib/guardrails.js';
-import { rules } from '../lib/rules.js';
+import { rules, guardrails } from '../noop.js';
 
 function isGuardrailsConfig(value) {
   return Boolean(value) && typeof value === 'object';
@@ -33,17 +32,18 @@ function createFeatureTree(signalTree, initial, options) {
   if (isDev || isTest) {
     const guardrailsConfig = resolveGuardrailsConfig(options.guardrails);
     if (guardrailsConfig) {
-      enhancers.push(withGuardrails(guardrailsConfig));
+      enhancers.push(guardrails(guardrailsConfig));
     }
   }
   if (options.enhancers?.length) {
     enhancers.push(...options.enhancers);
   }
-  let tree = signalTree(initial);
+  const tree = signalTree(initial);
+  let enhanced = tree;
   for (const enhancer of enhancers) {
-    tree = tree.with(enhancer);
+    enhanced = enhanced.with(enhancer);
   }
-  return tree;
+  return enhanced;
 }
 function createAngularFeatureTree(signalTree, initial, options) {
   const isDev = Boolean(ngDevMode);

package/dist/lib/guardrails.js

@@ -1,4 +1,5 @@
 import { getPathNotifier } from '@signaltree/core';
+import { deepEqual } from '@signaltree/shared';
 
 function isFunction(value) {
   return typeof value === 'function';
@@ -26,7 +27,11 @@ function tryStructuredClone(value) {
       return cloneFn(value);
     } catch {}
   }
-  return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
 }
 function isDevEnvironment() {
   if (__DEV__ !== undefined) return __DEV__;
@@ -37,16 +42,16 @@ function isDevEnvironment() {
 const MAX_TIMING_SAMPLES = 1000;
 const RECOMPUTATION_WINDOW_MS = 1000;
 const POLLING_INTERVAL_MS = 50;
-function withGuardrails(config = {}) {
-  return tree => {
+function guardrails(config = {}) {
+  return function (tree) {
     const enabled = resolveEnabledFlag(config.enabled);
     if (!isDevEnvironment() || !enabled) {
       return tree;
     }
     const stats = createRuntimeStats();
     const context = {
-      tree,
-      config,
+      tree: tree,
+      config: config,
       stats,
       issues: [],
       hotPaths: [],
@@ -98,6 +103,7 @@ function withGuardrails(config = {}) {
     return tree;
   };
 }
+const withGuardrails = Object.assign(guardrails, {});
 function startChangeDetection(context) {
   if (!context.config.changeDetection?.disablePathNotifier) {
     try {
@@ -111,10 +117,13 @@ function startChangeDetection(context) {
     } catch {}
   }
   try {
-    const unsubscribe = context.tree.subscribe(() => {
-      handleStateChange(context);
-    });
-    return unsubscribe;
+    const maybeSubscribe = context.tree.subscribe;
+    if (typeof maybeSubscribe === 'function') {
+      const unsubscribe = maybeSubscribe.call(context.tree, () => {
+        handleStateChange(context);
+      });
+      return unsubscribe;
+    }
   } catch {}
   return startPollingChangeDetection(context);
 }
@@ -146,9 +155,8 @@ function handleStateChange(context) {
     context.previousState = tryStructuredClone(currentState);
     return;
   }
-  const currentJson = JSON.stringify(currentState);
-  const previousJson = JSON.stringify(previousState);
-  if (currentJson !== previousJson) {
+  const equal = deepEqual(currentState, previousState);
+  if (!equal) {
     const startTime = performance.now();
     const timestamp = Date.now();
     const changedPaths = detectChangedPaths(previousState, currentState);
@@ -614,4 +622,4 @@ function isComparableRecord(value) {
   return isPlainObject(value);
 }
 
-export { withGuardrails };
+export { guardrails, withGuardrails };

package/dist/noop.js

@@ -5,17 +5,17 @@ const noopRule = name => ({
   message: '',
   severity: 'info'
 });
-function withGuardrails(config) {
+function guardrails(config = {}) {
   return tree => {
     return tree;
   };
 }
 const rules = {
-  noDeepNesting: () => noopRule('noop'),
+  noDeepNesting: (_maxDepth = 5) => noopRule('noop'),
   noFunctionsInState: () => noopRule('noop'),
   noCacheInPersistence: () => noopRule('noop'),
-  maxPayloadSize: () => noopRule('noop'),
-  noSensitiveData: () => noopRule('noop')
+  maxPayloadSize: (_maxKB = 100) => noopRule('noop'),
+  noSensitiveData: (_sensitiveKeys = ['password', 'token', 'secret', 'apiKey']) => noopRule('noop')
 };
 
-export { rules, withGuardrails };
+export { guardrails, rules };

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@signaltree/guardrails",
-  "version": "5.1.6",
+  "version": "6.0.1",
   "description": "Development-only performance monitoring and anti-pattern detection for SignalTree",
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/lib/guardrails.js",
-  "module": "./dist/lib/guardrails.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./src/index.d.ts",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
       "development": {
-        "import": "./dist/lib/guardrails.js",
-        "default": "./dist/lib/guardrails.js"
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
       },
       "production": {
         "import": "./dist/noop.js",
@@ -57,7 +57,8 @@
     "type-check": "tsc --project tsconfig.lib.json --noEmit"
   },
   "peerDependencies": {
-    "@signaltree/core": "^5.0.0",
+    "@signaltree/core": "^6.0.0",
+    "@signaltree/shared": "^6.0.0",
     "tslib": "^2.0.0",
     "vitest": "^2.0.0"
   },
@@ -68,8 +69,7 @@
   },
   "devDependencies": {
     "@signaltree/core": "workspace:*",
-    "@signaltree/shared": "workspace:*",
-    "@signaltree/types": "workspace:*"
+    "@signaltree/shared": "workspace:*"
   },
   "keywords": [
     "signaltree",

package/src/factories/index.d.ts

@@ -1,20 +1,19 @@
-import type { SignalTree, TreeConfig } from '@signaltree/core';
+import type { ISignalTree, TreeConfig, Enhancer } from '@signaltree/core';
 import type { GuardrailsConfig } from '../lib/types';
-type SignalTreeFactory<T extends Record<string, unknown>> = (initial: T, config?: TreeConfig) => SignalTree<T>;
-type EnhancerFn<T extends Record<string, unknown>> = (tree: SignalTree<T>) => SignalTree<T>;
+type SignalTreeFactory<T extends Record<string, unknown>> = (initial: T, config?: TreeConfig) => ISignalTree<T>;
 interface FeatureTreeOptions<T extends Record<string, unknown>> {
     name: string;
     env?: 'development' | 'test' | 'staging' | 'production';
     persistence?: boolean | Record<string, unknown>;
-    guardrails?: boolean | GuardrailsConfig;
+    guardrails?: boolean | GuardrailsConfig<T>;
     devtools?: boolean;
-    enhancers?: EnhancerFn<T>[];
+    enhancers?: Enhancer<unknown>[];
 }
-export declare function createFeatureTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, options: FeatureTreeOptions<T>): SignalTree<T>;
-export declare function createAngularFeatureTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, options: Omit<FeatureTreeOptions<T>, 'env'>): SignalTree<T>;
-export declare function createAppShellTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T): SignalTree<T>;
-export declare function createPerformanceTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, name: string): SignalTree<T>;
-export declare function createFormTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, formName: string): SignalTree<T>;
-export declare function createCacheTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T): SignalTree<T>;
-export declare function createTestTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, overrides?: Partial<GuardrailsConfig>): SignalTree<T>;
+export declare function createFeatureTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, options: FeatureTreeOptions<T>): ISignalTree<T>;
+export declare function createAngularFeatureTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, options: Omit<FeatureTreeOptions<T>, 'env'>): ISignalTree<T>;
+export declare function createAppShellTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T): ISignalTree<T>;
+export declare function createPerformanceTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, name: string): ISignalTree<T>;
+export declare function createFormTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, formName: string): ISignalTree<T>;
+export declare function createCacheTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T): ISignalTree<T>;
+export declare function createTestTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, overrides?: Partial<GuardrailsConfig<T>>): ISignalTree<T>;
 export {};

package/src/index.d.ts

@@ -1,4 +1,4 @@
-import { withGuardrails } from './lib/guardrails';
+import { guardrails } from './lib/guardrails';
 import { rules } from './lib/rules';
-export { withGuardrails, rules };
+export { guardrails, rules };
 export type * from './lib/types';

package/src/lib/guardrails.d.ts

@@ -1,3 +1,6 @@
-import type { SignalTree } from '@signaltree/core';
-import type { GuardrailsConfig } from './types';
-export declare function withGuardrails<T extends Record<string, unknown>>(config?: GuardrailsConfig<T>): (tree: SignalTree<T>) => SignalTree<T>;
+import type { ISignalTree } from '@signaltree/core';
+import type { GuardrailsConfig, GuardrailsAPI } from './types';
+export declare function guardrails(config?: GuardrailsConfig<any>): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & {
+    __guardrails?: GuardrailsAPI;
+};
+export declare const withGuardrails: typeof guardrails;

package/src/lib/types.d.ts

@@ -1,5 +1,5 @@
-import type { SignalTree } from '@signaltree/core';
-export interface GuardrailsConfig<T extends Record<string, unknown> = Record<string, unknown>> {
+import type { ISignalTree } from '@signaltree/core';
+export interface GuardrailsConfig<T = Record<string, unknown>> {
     mode?: 'warn' | 'throw' | 'silent';
     enabled?: boolean | (() => boolean);
     changeDetection?: {
@@ -57,7 +57,7 @@ export interface UpdateMetadata {
     correlationId?: string;
     [key: string]: unknown;
 }
-export interface GuardrailRule<T extends Record<string, unknown> = Record<string, unknown>> {
+export interface GuardrailRule<T = Record<string, unknown>> {
     name: string;
     description?: string;
     test: (context: RuleContext<T>) => boolean | Promise<boolean>;
@@ -66,12 +66,12 @@ export interface GuardrailRule<T extends Record<string, unknown> = Record<string
     fix?: (context: RuleContext<T>) => void;
     tags?: string[];
 }
-export interface RuleContext<T extends Record<string, unknown> = Record<string, unknown>> {
+export interface RuleContext<T = Record<string, unknown>> {
     path: string[];
     value: unknown;
     oldValue?: unknown;
     metadata?: UpdateMetadata;
-    tree: SignalTree<T>;
+    tree: ISignalTree<T>;
     duration?: number;
     diffRatio?: number;
     recomputeCount?: number;

package/src/noop.d.ts

@@ -1,11 +1,10 @@
-import type { SignalTree } from '@signaltree/core';
 import type { GuardrailsConfig, GuardrailRule } from './lib/types';
-export declare function withGuardrails<T extends Record<string, unknown>>(config?: GuardrailsConfig): (tree: SignalTree<T>) => SignalTree<T>;
+export declare function guardrails(config?: GuardrailsConfig<any>): <S>(tree: import("@signaltree/core").SignalTree<S>) => import("@signaltree/core").SignalTree<S>;
 export declare const rules: {
-    noDeepNesting: () => GuardrailRule<Record<string, unknown>>;
+    noDeepNesting: (_maxDepth?: number) => GuardrailRule<Record<string, unknown>>;
     noFunctionsInState: () => GuardrailRule<Record<string, unknown>>;
     noCacheInPersistence: () => GuardrailRule<Record<string, unknown>>;
-    maxPayloadSize: () => GuardrailRule<Record<string, unknown>>;
-    noSensitiveData: () => GuardrailRule<Record<string, unknown>>;
+    maxPayloadSize: (_maxKB?: number) => GuardrailRule<Record<string, unknown>>;
+    noSensitiveData: (_sensitiveKeys?: string[]) => GuardrailRule<Record<string, unknown>>;
 };
-export type * from './lib/types';
+export * from './lib/types';

package/dist/lib/rules.js

@@ -1,62 +0,0 @@
-const rules = {
-  noDeepNesting: (maxDepth = 5) => ({
-    name: 'no-deep-nesting',
-    description: `Prevents nesting deeper than ${maxDepth} levels`,
-    test: ctx => ctx.path.length <= maxDepth,
-    message: ctx => `Path too deep: ${ctx.path.join('.')} (${ctx.path.length} levels, max: ${maxDepth})`,
-    severity: 'warning',
-    tags: ['architecture', 'complexity']
-  }),
-  noFunctionsInState: () => ({
-    name: 'no-functions',
-    description: 'Functions break serialization',
-    test: ctx => typeof ctx.value !== 'function',
-    message: 'Functions cannot be stored in state (breaks serialization)',
-    severity: 'error',
-    tags: ['serialization', 'data']
-  }),
-  noCacheInPersistence: () => ({
-    name: 'no-cache-persistence',
-    description: 'Prevent cache from being persisted',
-    test: ctx => {
-      if (ctx.metadata?.source === 'serialization' && ctx.path.includes('cache')) {
-        return false;
-      }
-      return true;
-    },
-    message: 'Cache should not be persisted',
-    severity: 'warning',
-    tags: ['persistence', 'cache']
-  }),
-  maxPayloadSize: (maxKB = 100) => ({
-    name: 'max-payload-size',
-    description: `Limit payload size to ${maxKB}KB`,
-    test: ctx => {
-      try {
-        const size = JSON.stringify(ctx.value).length;
-        return size < maxKB * 1024;
-      } catch {
-        return true;
-      }
-    },
-    message: ctx => {
-      const size = JSON.stringify(ctx.value).length;
-      const kb = (size / 1024).toFixed(1);
-      return `Payload size ${kb}KB exceeds limit of ${maxKB}KB`;
-    },
-    severity: 'warning',
-    tags: ['performance', 'data']
-  }),
-  noSensitiveData: (sensitiveKeys = ['password', 'token', 'secret', 'apiKey']) => ({
-    name: 'no-sensitive-data',
-    description: 'Prevents storing sensitive data',
-    test: ctx => {
-      return !ctx.path.some(segment => sensitiveKeys.some(key => typeof segment === 'string' && segment.toLowerCase().includes(key.toLowerCase())));
-    },
-    message: ctx => `Sensitive data detected in path: ${ctx.path.join('.')}`,
-    severity: 'error',
-    tags: ['security', 'data']
-  })
-};
-
-export { rules };