@svadmin/core 0.23.1 → 0.23.3

package/src/permissions.test.ts

@@ -1,149 +1,102 @@
-// Unit tests for permissions module
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccessAsync, type CanParams, type CanResult } from './permissions';
-import type { Action, AccessControlProvider } from './permissions';
+import { describe, test, expect } from 'bun:test';
+import type { CanParams, CanResult, Action, AccessControlProvider } from './permissions.svelte';
 
 describe('permissions', () => {
-  beforeEach(() => {
-    // Reset to a permissive provider
-    setAccessControlProvider({
-      can: async () => ({ can: true }),
-    });
-  });
-
   test('canAccessAsync respects deny rule', async () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async (p) => {
         const { action } = p as CanParams;
         if (action === 'delete') return { can: false, reason: 'Denied' };
         return { can: true };
       },
-    });
-    expect(await canAccessAsync('posts', 'delete')).toEqual({ can: false, reason: 'Denied' });
-    expect((await canAccessAsync('posts', 'delete')) as CanResult).toEqual({ can: false, reason: 'Denied' });
-    expect((await canAccessAsync('posts', 'list')) as CanResult).toEqual({ can: true });
+    };
+    expect(await provider.can({ resource: 'posts', action: 'delete' })).toEqual({ can: false, reason: 'Denied' });
+    expect((await provider.can({ resource: 'posts', action: 'list' })) as CanResult).toEqual({ can: true });
   });
 
   test('canAccessAsync resolves with allowed status', async () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async (params) => {
         expect((params as CanParams).params?.published).toBe(true);
         return { can: true };
       },
-    });
-    const result = await canAccessAsync('posts', 'edit', { published: true });
+    };
+    const result = await provider.can({ resource: 'posts', action: 'edit', params: { published: true } });
     expect((result as CanResult).can).toBe(true);
   });
 
   test('canAccessAsync resolves with denied status', async () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async () => ({ can: false, reason: 'No permission' }),
-    });
-    const result = await canAccessAsync('users', 'delete');
+    };
+    const result = await provider.can({ resource: 'users', action: 'delete' });
     expect((result as CanResult).can).toBe(false);
     expect((result as CanResult).reason).toBe('No permission');
   });
 
   test('resource-specific rules', async () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async (p) => {
         const { resource, action } = p as CanParams;
         if (resource === 'users' && action === 'delete') return { can: false, reason: 'Cannot delete users' };
         return { can: true };
       },
-    });
-    expect((await canAccessAsync('users', 'delete') as CanResult).can).toBe(false);
-    expect((await canAccessAsync('users', 'list') as CanResult).can).toBe(true);
-    expect((await canAccessAsync('posts', 'delete') as CanResult).can).toBe(true);
-  });
-});
-
-describe('AccessControlProvider', () => {
-  beforeEach(() => {
-    setAccessControlProvider({
-      can: async () => ({ can: true }),
-    });
-  });
-
-  test('setAccessControlProvider registers a provider', () => {
-    const provider = getAccessControlProvider();
-    expect(provider).not.toBeNull();
-  });
-
-  test('provider can() is called via canAccessAsync', async () => {
-    let callCount = 0;
-    setAccessControlProvider({
-      can: async (params) => {
-        callCount++;
-        expect((params as CanParams).resource).toBe('posts');
-        if ((params as CanParams).action === 'delete') {
-          return { can: false, reason: 'Cannot delete posts' };
-        }
-        return { can: true };
-      },
-    });
-    const denied = await canAccessAsync('posts', 'delete') as CanResult;
-    expect(denied.can).toBe(false);
-    expect(denied.reason).toBe('Cannot delete posts');
-
-    const allowed = await canAccessAsync('posts', 'list') as CanResult;
-    expect(allowed.can).toBe(true);
-    expect(callCount).toBe(2);
+    };
+    expect((await provider.can({ resource: 'users', action: 'delete' }) as CanResult).can).toBe(false);
+    expect((await provider.can({ resource: 'users', action: 'list' }) as CanResult).can).toBe(true);
+    expect((await provider.can({ resource: 'posts', action: 'delete' }) as CanResult).can).toBe(true);
   });
 
   test('params.id is passed through', async () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async (p) => {
         const { params } = p as CanParams;
         if (params?.id === 42) return { can: false, reason: 'Record locked' };
         return { can: true };
       },
-    });
-    const result = await canAccessAsync('posts', 'edit', { id: 42 });
+    };
+    const result = await provider.can({ resource: 'posts', action: 'edit', params: { id: 42 } });
     expect((result as CanResult).can).toBe(false);
     expect((result as CanResult).reason).toBe('Record locked');
   });
 
   test('extended action types work', async () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async (p) => {
         const { action } = p as CanParams;
         if (action === 'show') return { can: false, reason: 'No show' };
         if (action === 'field') return { can: false, reason: 'No field' };
         return { can: true };
       },
-    });
-    expect(((await canAccessAsync('posts', 'show')) as CanResult).can).toBe(false);
-    expect(((await canAccessAsync('posts', 'field')) as CanResult).can).toBe(false);
-    expect(((await canAccessAsync('posts', 'list')) as CanResult).can).toBe(true);
+    };
+    expect(((await provider.can({ resource: 'posts', action: 'show' })) as CanResult).can).toBe(false);
+    expect(((await provider.can({ resource: 'posts', action: 'field' })) as CanResult).can).toBe(false);
+    expect(((await provider.can({ resource: 'posts', action: 'list' })) as CanResult).can).toBe(true);
   });
 
   test('getAccessControlOptions returns provider options', () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async () => ({ can: true }),
       options: {
         buttons: { enableAccessControl: true, hideIfUnauthorized: true },
       },
-    });
-    const options = getAccessControlOptions();
-    expect(options.buttons?.enableAccessControl).toBe(true);
-    expect(options.buttons?.hideIfUnauthorized).toBe(true);
+    };
+    expect(provider.options?.buttons?.enableAccessControl).toBe(true);
+    expect(provider.options?.buttons?.hideIfUnauthorized).toBe(true);
   });
 
   test('getAccessControlOptions returns {} when no options', () => {
-    setAccessControlProvider({
+    const provider: AccessControlProvider = {
       can: async () => ({ can: true }),
-    });
-    expect(getAccessControlOptions()).toEqual({});
+    };
+    expect(provider.options).toBeUndefined();
   });
 });
 
 describe('CASL adapter', () => {
   test('createCaslAccessControl works', async () => {
-    // Import dynamically to test the adapter
     const { createCaslAccessControl } = await import('./adapters/casl');
 
-    // Mock CASL Ability
     const ability = {
       can: (action: string, subject: string) => !(action === 'delete' && subject === 'users'),
       cannot: (action: string, subject: string) => action === 'delete' && subject === 'users',
@@ -164,7 +117,6 @@ describe('Casbin adapter', () => {
   test('createCasbinAccessControl works', async () => {
     const { createCasbinAccessControl } = await import('./adapters/casbin');
 
-    // Mock Casbin Enforcer
     const enforcer = {
       enforce: async (sub: string, obj: string, act: string) =>
         !(sub === 'alice' && obj === 'users' && act === 'delete'),

package/src/query-hooks.svelte.ts

@@ -102,6 +102,7 @@ export function useList<TData extends BaseRecord = BaseRecord, TError = HttpErro
       },
       liveParams: opts.liveParams,
       enabled: opts.queryOptions?.enabled ?? true,
+      dataProviderName: opts.dataProviderName,
     };
   });
 
@@ -110,13 +111,15 @@ export function useList<TData extends BaseRecord = BaseRecord, TError = HttpErro
   let lastErrorAt = 0;
   $effect(() => {
     const opts = getOptions();
-    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && opts.successNotification) {
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
-      fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+      if (opts.successNotification) {
+        fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+      }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error);
-      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error, getResource());
     }
   });
 
@@ -187,6 +190,7 @@ export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError
       },
       liveParams: opts.liveParams,
       enabled: (opts.queryOptions?.enabled ?? true) && getId() != null,
+      dataProviderName: opts.dataProviderName,
     };
   });
 
@@ -194,13 +198,15 @@ export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError
   let lastErrorAt = 0;
   $effect(() => {
     const opts = getOptions();
-    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && opts.successNotification) {
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
-      fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+      if (opts.successNotification) {
+        fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+      }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error);
-      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error, getResource());
     }
   });
 
@@ -286,6 +292,7 @@ export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpErro
       },
       liveParams: opts.liveParams,
       enabled: (opts.queryOptions?.enabled ?? true) && opts.ids.length > 0,
+      dataProviderName: opts.dataProviderName,
     };
   });
 
@@ -293,13 +300,15 @@ export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpErro
   let lastErrorAt = 0;
   $effect(() => {
     const opts = getOptions();
-    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && opts.successNotification) {
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
-      fireSuccessNotification(opts.successNotification, '', query.data, undefined, opts.resource);
+      if (opts.successNotification) {
+        fireSuccessNotification(opts.successNotification, '', query.data, undefined, opts.resource);
+      }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error);
-      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error, opts.resource);
     }
   });
 

package/src/query-hooks.test.svelte.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi } from 'vitest';
+import { useList, useOne } from './query-hooks.svelte';
+import { flushSync } from 'svelte';
+import { QueryClient } from '@tanstack/svelte-query';
+
+vi.mock('./context.svelte', () => ({
+  useDataProvider: () => ({
+    getOne: vi.fn(),
+    getList: vi.fn()
+  }),
+  useResource: () => ({ name: 'posts' }),
+  getResource: (name: string) => ({ name, primaryKey: 'id' }),
+  useRouterContext: () => ({ navigate: vi.fn() }),
+  useTranslate: () => (key: string) => key,
+  useNotification: () => ({ open: vi.fn(), close: vi.fn() }),
+  getLiveProvider: () => undefined
+}));
+
+vi.mock('@tanstack/svelte-query', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual as any,
+    useQueryClient: () => new QueryClient(),
+    createQuery: () => ({
+      data: { data: [{ id: 1, title: 'One' }], title: 'One' }, // Unified mock to please both array and direct object assertions
+      isPending: false,
+      isFetching: false,
+      error: null
+    })
+  };
+});
+
+describe('useList & useOne - Headless Svelte 5 Compatibility', () => {
+
+  it('safely binds useList query state without headless Svelte destruction', () => {
+    let listQuery: ReturnType<typeof useList>;
+    
+    const cleanup = $effect.root(() => {
+        listQuery = useList({ resource: 'posts' });
+    });
+
+    flushSync();
+    
+    expect(listQuery!.data).toBeDefined();
+    expect(listQuery!.data!.data[0].title).toBe('One');
+    expect(listQuery!.isPending).toBe(false);
+
+    cleanup();
+  });
+
+  it('safely binds useOne query state without headless component mounting', () => {
+    let oneQuery: ReturnType<typeof useOne>;
+    
+    const cleanup = $effect.root(() => {
+        oneQuery = useOne({ resource: 'posts', id: 1 });
+    });
+
+    flushSync();
+    
+    expect(oneQuery!.data).toBeDefined();
+    expect((oneQuery!.data!.data as any).title).toBe('One');
+
+    cleanup();
+  });
+});

package/src/query-keys.ts

@@ -1,17 +1,16 @@
 export const keys = () => {
-  let _data = 'default';
+  let _dataProviderName: string | undefined = undefined;
   let _resource = '';
   let _action = '';
   let _params: unknown = undefined;
 
   const builder = {
-    data: (name: string) => { _data = name; return builder; },
+    data: (name: string | undefined) => { _dataProviderName = name; return builder; },
     resource: (name: string) => { _resource = name; return builder; },
     action: (name: string) => { _action = name; return builder; },
     params: (params: unknown) => { _params = params; return builder; },
     get: (): unknown[] => {
-      const parts: unknown[] = ['data', _data];
-      if (_resource) parts.push(_resource);
+      const parts: unknown[] = [_dataProviderName, _resource];
       if (_action) parts.push(_action);
       if (_params !== undefined) parts.push(_params);
       return parts;

package/src/reactive-hooks.test.svelte.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { useThemedLayoutContext } from './hooks.svelte';
+
+describe('Svelte 5 Reactive Runes Compatibility', () => {
+
+  it('verifies that sidebarCollapsed is correctly synchronized out of component lifecycle', () => {
+    let observedValue = false;
+    let layout: ReturnType<typeof useThemedLayoutContext>;
+    
+    const cleanup = $effect.root(() => {
+        layout = useThemedLayoutContext();
+        
+        $effect(() => {
+           observedValue = layout.sidebarCollapsed;
+        });
+    });
+
+    expect(observedValue).toBe(false);
+
+    layout!.toggleSidebar();
+
+    expect(layout!.sidebarCollapsed).toBe(true);
+
+    cleanup();
+  });
+});

package/src/router-provider.test.ts

@@ -3,6 +3,9 @@
 // Skip if window is not available (CI without happy-dom).
 import { describe, test, expect } from 'bun:test';
 import { createHashRouterProvider, createHistoryRouterProvider } from './router-provider';
+import { GlobalRegistrator } from '@happy-dom/global-registrator';
+
+GlobalRegistrator.register();
 
 const hasWindow = typeof globalThis.window !== 'undefined';
 

package/src/router-provider.ts

@@ -26,13 +26,14 @@ export interface RouterProvider {
 
 export function createHashRouterProvider(): RouterProvider {
   return {
-    go({ to, query, type = 'push' }) {
+    go({ to, query, hash, type = 'push' }) {
       if (typeof window === 'undefined') return;
       let url = to;
       if (query) {
         const params = new URLSearchParams(query).toString();
-        if (params) url += `?${params}`;
+        if (params) url += url.includes('?') ? `&${params}` : `?${params}`;
       }
+      if (hash) url += `#${hash}`;
       if (type === 'replace') {
         const urlObj = new URL(window.location.href);
         urlObj.hash = url;
@@ -76,20 +77,21 @@ export function createHashRouterProvider(): RouterProvider {
 // ─── History Router (HTML5 pushState) ───────────────────────
 
 export function createHistoryRouterProvider(basePath = ''): RouterProvider {
+  const normalizedBase = basePath.endsWith('/') && basePath.length > 1 ? basePath.slice(0, -1) : basePath;
   return {
-    go({ to, query, type = 'push' }) {
+    go({ to, query, hash, type = 'push' }) {
       if (typeof window === 'undefined') return;
-      let url = `${basePath}${to}`;
+      let url = `${normalizedBase}${to}`;
       if (query) {
         const params = new URLSearchParams(query).toString();
-        if (params) url += `?${params}`;
+        if (params) url += url.includes('?') ? `&${params}` : `?${params}`;
       }
+      if (hash) url += `#${hash}`;
       if (type === 'replace') {
         history.replaceState(null, '', url);
       } else {
         history.pushState(null, '', url);
       }
-      // Dispatch event so other parts of the app can react
       window.dispatchEvent(new PopStateEvent('popstate'));
     },
     back() {
@@ -100,8 +102,10 @@ export function createHistoryRouterProvider(basePath = ''): RouterProvider {
       if (typeof window === 'undefined') {
         return { resource: undefined, action: undefined, id: undefined, params: {}, pathname: '/' };
       }
-      const pathname = (basePath && window.location.pathname.startsWith(basePath)
-        ? window.location.pathname.slice(basePath.length) || '/'
+      const fullPath = window.location.pathname;
+      const pathname = (normalizedBase && fullPath.startsWith(normalizedBase)
+        && (fullPath.length === normalizedBase.length || fullPath[normalizedBase.length] === '/')
+        ? fullPath.slice(normalizedBase.length) || '/'
         : window.location.pathname);
       const params: Record<string, string> = {};
       for (const [k, v] of new URLSearchParams(window.location.search).entries()) {
@@ -117,7 +121,7 @@ export function createHistoryRouterProvider(basePath = ''): RouterProvider {
       };
     },
     formatLink(path) {
-      return basePath + path;
+      return normalizedBase + path;
     },
   };
 }

package/src/router.ts

@@ -1,6 +1,7 @@
 // Router — path matching + navigation (supports hash & history via RouterProvider)
 
 import type { RouterProvider } from './router-provider';
+import { syncGlobalPath } from './useParsed.svelte';
 
 interface RouteMatch {
   route: string;
@@ -74,6 +75,7 @@ export async function navigate(path: string, options?: { replaceState?: boolean
   } else if (typeof window !== 'undefined') {
     window.location.hash = '#' + path.replace(/^#/, '');
   }
+  syncGlobalPath();
   for (const guard of _afterGuards) {
     guard(path, from);
   }
@@ -102,3 +104,9 @@ export function currentPath(): string {
   if (typeof window === 'undefined') return '/';
   return window.location.hash.replace(/^#/, '') || '/';
 }
+
+export function resetRouter(): void {
+  _routerProvider = undefined;
+  _beforeGuards = [];
+  _afterGuards = [];
+}

package/src/routing-hooks.svelte.ts

@@ -39,7 +39,6 @@ export function useGetToPath() {
 
 export function useGo() {
   const getToPath = useGetToPath();
-  const routerProvider = getRouterProvider();
 
   return (options: { to?: string; query?: Record<string, unknown>; type?: 'push' | 'replace'; resource?: string; action?: 'list' | 'create' | 'edit' | 'show' | 'clone'; id?: string | number }) => {
     let targetUrl = options.to;
@@ -49,21 +48,19 @@ export function useGo() {
     if (!targetUrl) targetUrl = '/';
 
     if (options.query && Object.keys(options.query).length > 0) {
-      const qs = new URLSearchParams(options.query as Record<string, string>).toString();
-      targetUrl += `?${qs}`;
+      const qs = new URLSearchParams(Object.entries(options.query).map(([k, v]) => [k, String(v)])).toString();
+      if (qs) {
+        targetUrl += targetUrl.includes('?') ? `&${qs}` : `?${qs}`;
+      }
     }
 
-    if (routerProvider?.go) {
-      routerProvider.go({ to: targetUrl, type: options.type });
-    } else {
-      navigate(targetUrl, options.type === 'replace' ? { replaceState: true } : undefined);
-    }
+    navigate(targetUrl, options.type === 'replace' ? { replaceState: true } : undefined);
   };
 }
 
 export function useBack() {
-  const routerProvider = getRouterProvider();
   return () => {
+    const routerProvider = getRouterProvider();
     if (routerProvider?.back) {
       routerProvider.back();
     } else if (typeof window !== 'undefined') {
@@ -77,8 +74,10 @@ export function useBack() {
  * (to avoid full page reloads in SSR apps)
  */
 export function useLink() {
-  const routerProvider = getRouterProvider() as Record<string, unknown> | undefined;
-  return (routerProvider?.Link as string) ?? 'a';
+  return () => {
+    const routerProvider = getRouterProvider() as Record<string, unknown> | undefined;
+    return (routerProvider?.Link as string) ?? 'a';
+  };
 }
 
 export function useResource(resourceName?: string) {
@@ -101,8 +100,12 @@ export function useResource(resourceName?: string) {
     get identifier() { return resolvedResource?.identifier ?? resolvedResource?.name; },
     /** Resolve a resource by name — useful for dynamic lookups inside callbacks */
     select: (name: string) => {
-      const res = getResource(name);
-      return { resource: res, identifier: res.identifier ?? res.name };
+      try {
+        const res = getResource(name);
+        return { resource: res, identifier: res.identifier ?? res.name };
+      } catch {
+        return { resource: undefined, identifier: undefined };
+      }
     },
   };
 }

package/src/routing-hooks.test.svelte.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from 'vitest';
+import { useGo, useBack } from './routing-hooks.svelte';
+import { useParsed } from './useParsed.svelte';
+import { flushSync } from 'svelte';
+
+vi.mock('./context.svelte', () => ({
+  useRouterContext: () => ({ 
+    navigate: vi.fn(), 
+    url: '/posts/1/edit',
+    parsedParams: { resource: 'posts', action: 'edit', id: '1' },
+    go: vi.fn(),
+    back: vi.fn()
+  }),
+  getRouterProvider: () => undefined
+}));
+
+vi.mock('./useParsed.svelte', () => ({
+  useParsed: () => ({ resource: 'posts', action: 'edit', id: '1' })
+}));
+
+describe('routing-hooks - Headless Svelte 5 Compatibility', () => {
+
+  it('safely extracts parses from url and binds to runes Context', () => {
+    let parsedParams!: ReturnType<typeof useParsed>;
+
+    const cleanup = $effect.root(() => {
+        parsedParams = useParsed();
+    });
+
+    flushSync();
+    
+    expect(parsedParams!.action).toBe('edit');
+    expect(parsedParams.resource).toBe('posts');
+    expect(parsedParams.id).toBe('1');
+
+    cleanup();
+  });
+
+  it('useGo and useBack return functional closures out of Context', () => {
+    let go!: ReturnType<typeof useGo>;
+    let back!: ReturnType<typeof useBack>;
+    
+    const cleanup = $effect.root(() => {
+        go = useGo();
+        back = useBack();
+    });
+
+    flushSync();
+    
+    expect(typeof go).toBe('function');
+    expect(typeof back).toBe('function');
+
+    cleanup();
+  });
+});

package/src/table-hooks.svelte.ts

@@ -138,7 +138,7 @@ export function useTable<
         if (newPage !== pagination.current) {
           pagination = { ...pagination, current: newPage };
         }
-        const newPageSize = urlState.pageSize ?? initialOpts.pagination?.pageSize ?? getAdminOptions().defaultPageSize ?? 10;
+        const newPageSize = urlState.pageSize ?? getOptions().pagination?.pageSize ?? getAdminOptions().defaultPageSize ?? 10;
         if (newPageSize !== pagination.pageSize) {
           pagination = { ...pagination, pageSize: newPageSize };
         }
@@ -220,6 +220,51 @@ export function useTable<
           return 0;
         });
       }
+      const activeFilters = filtersMode === 'off' ? effectiveFilters : [];
+      if (activeFilters.length > 0) {
+        function matchesFilter(item: Record<string, unknown>, f: Filter): boolean {
+          if (!('field' in f)) {
+            if (f.operator === 'and') return f.value.every(sub => matchesFilter(item, sub));
+            if (f.operator === 'or') return f.value.length === 0 || f.value.some(sub => matchesFilter(item, sub));
+            return true;
+          }
+          const val = item[f.field];
+          const fv = f.value;
+          switch (f.operator) {
+            case 'null': return val == null;
+            case 'nnull': return val != null;
+            default: break;
+          }
+          if (fv == null || fv === '') return true;
+          switch (f.operator) {
+            case 'eq': return val == fv;
+            case 'ne': return val != fv;
+            case 'lt': return typeof val === 'number' && typeof fv === 'number' && val < fv;
+            case 'gt': return typeof val === 'number' && typeof fv === 'number' && val > fv;
+            case 'lte': return typeof val === 'number' && typeof fv === 'number' && val <= fv;
+            case 'gte': return typeof val === 'number' && typeof fv === 'number' && val >= fv;
+            case 'in': return !Array.isArray(fv) || fv.length === 0 || fv.includes(val);
+            case 'nin': return !Array.isArray(fv) || fv.length === 0 || !fv.includes(val);
+            case 'contains': return typeof val === 'string' && typeof fv === 'string' && val.includes(fv);
+            case 'ncontains': return typeof val === 'string' && typeof fv === 'string' && !val.includes(fv);
+            case 'startswith': return typeof val === 'string' && typeof fv === 'string' && val.startsWith(fv);
+            case 'endswith': return typeof val === 'string' && typeof fv === 'string' && val.endsWith(fv);
+            case 'between': {
+              if (!Array.isArray(fv) || fv.length !== 2) return true;
+              return typeof val === 'number' && val >= (fv[0] as number) && val <= (fv[1] as number);
+            }
+            case 'nbetween': {
+              if (!Array.isArray(fv) || fv.length !== 2) return true;
+              return typeof val === 'number' && (val < (fv[0] as number) || val > (fv[1] as number));
+            }
+            default: return true;
+          }
+        }
+        sorted = sorted.filter((item) => {
+          const rec = item as Record<string, unknown>;
+          return activeFilters.every(f => matchesFilter(rec, f));
+        });
+      }
       if (paginationMode === 'off') return sorted;
       const start = ((pagination.current ?? 1) - 1) * (pagination.pageSize ?? 10);
       const end = start + (pagination.pageSize ?? 10);