@svadmin/core 0.22.1 → 0.23.1

package/src/helpers-pure.ts

@@ -0,0 +1,159 @@
+// Pure utility functions — no Svelte runtime dependency
+// Extracted to enable unit testing with bun test
+
+import type { Filter, Sort, CrudOperator } from './types';
+
+// ─── Table Helpers ────────────────────────────────────────────
+
+/**
+ * Get the current filter value for a field from a filter array.
+ */
+export function getDefaultFilter(
+  columnName: string,
+  filters?: Filter[],
+  operatorType: CrudOperator = 'eq',
+): unknown | undefined {
+  if (!filters) return undefined;
+  const filter = filters.find((f) => {
+    if ('field' in f) {
+      return f.field === columnName && f.operator === operatorType;
+    }
+    return false;
+  });
+  return filter && 'value' in filter ? filter.value : undefined;
+}
+
+/**
+ * Get the current sort order for a field from a sorter array.
+ */
+export function getDefaultSortOrder(
+  columnName: string,
+  sorters?: Sort[],
+): 'asc' | 'desc' | undefined {
+  if (!sorters) return undefined;
+  const sortItem = sorters.find((item) => item.field === columnName);
+  return sortItem?.order as 'asc' | 'desc' | undefined;
+}
+
+/**
+ * Merge two filter arrays, deduplicating by field+operator.
+ */
+export function unionFilters(
+  permanentFilter: Filter[],
+  newFilters: Filter[],
+  prevFilters: Filter[] = [],
+): Filter[] {
+  const compareFilters = (a: Filter, b: Filter): boolean => {
+    if ('field' in a && 'field' in b) {
+      return a.field === b.field && a.operator === b.operator;
+    }
+    return false;
+  };
+
+  let result = [...prevFilters];
+
+  for (const newFilter of newFilters) {
+    const idx = result.findIndex((f) => compareFilters(f, newFilter));
+    if (idx >= 0) {
+      result[idx] = newFilter;
+    } else {
+      result.push(newFilter);
+    }
+  }
+
+  for (const perm of permanentFilter) {
+    const idx = result.findIndex((f) => compareFilters(f, perm));
+    if (idx >= 0) {
+      result[idx] = perm;
+    } else {
+      result.push(perm);
+    }
+  }
+
+  return result.filter((f) => !('value' in f && f.value === undefined));
+}
+
+/**
+ * Merge two sorter arrays, deduplicating by field.
+ */
+export function unionSorters(
+  permanentSorters: Sort[],
+  newSorters: Sort[],
+): Sort[] {
+  const result = [...newSorters];
+
+  for (const perm of permanentSorters) {
+    if (!result.some((s) => s.field === perm.field)) {
+      result.push(perm);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Convert a File to a base64 data URL string.
+ */
+export function file2Base64(file: File | { uid?: string } & Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file as Blob);
+    reader.addEventListener('load', () => {
+      resolve(reader.result as string);
+    });
+    reader.addEventListener('error', () => {
+      reject(reader.error);
+    });
+  });
+}
+
+/** Parse full CSV text respecting quoted multi-line fields */
+export function parseCSV(text: string): string[][] {
+  const rows: string[][] = [];
+  let currentRow: string[] = [];
+  let currentVal = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (i + 1 < text.length && text[i + 1] === '"') {
+          currentVal += '"';
+          i++; // skip escaped quote
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        currentVal += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ',') {
+        currentRow.push(currentVal.trim());
+        currentVal = '';
+      } else if (ch === '\n' || ch === '\r') {
+        currentRow.push(currentVal.trim());
+        if (currentRow.some(v => v !== '')) {
+          rows.push(currentRow);
+        }
+        currentRow = [];
+        currentVal = '';
+        if (ch === '\r' && i + 1 < text.length && text[i + 1] === '\n') {
+          i++; // consume \n of \r\n
+        }
+      } else {
+        currentVal += ch;
+      }
+    }
+  }
+  
+  if (currentVal || currentRow.length > 0) {
+    currentRow.push(currentVal.trim());
+    if (currentRow.some(v => v !== '')) {
+      rows.push(currentRow);
+    }
+  }
+  return rows;
+}

package/src/helpers.test.ts

@@ -0,0 +1,177 @@
+// Unit tests for helpers-pure.ts — pure functions, no Svelte runtime
+import { describe, test, expect } from 'bun:test';
+import {
+  getDefaultFilter, getDefaultSortOrder,
+  unionFilters, unionSorters,
+  parseCSV,
+} from './helpers-pure';
+import type { Filter, Sort } from './types';
+
+// ─── getDefaultFilter ─────────────────────────────────────────
+
+describe('getDefaultFilter', () => {
+  const filters: Filter[] = [
+    { field: 'status', operator: 'eq', value: 'published' },
+    { field: 'price', operator: 'gte', value: 100 },
+    { field: 'title', operator: 'contains', value: 'hello' },
+  ];
+
+  test('returns value for matching field+operator', () => {
+    expect(getDefaultFilter('status', filters)).toBe('published');
+    expect(getDefaultFilter('price', filters, 'gte')).toBe(100);
+  });
+
+  test('returns undefined for non-matching field', () => {
+    expect(getDefaultFilter('nonexistent', filters)).toBeUndefined();
+  });
+
+  test('returns undefined for wrong operator', () => {
+    expect(getDefaultFilter('status', filters, 'contains')).toBeUndefined();
+  });
+
+  test('returns undefined for empty/undefined filters', () => {
+    expect(getDefaultFilter('status', [])).toBeUndefined();
+    expect(getDefaultFilter('status', undefined)).toBeUndefined();
+  });
+});
+
+// ─── getDefaultSortOrder ──────────────────────────────────────
+
+describe('getDefaultSortOrder', () => {
+  const sorters: Sort[] = [
+    { field: 'name', order: 'asc' },
+    { field: 'createdAt', order: 'desc' },
+  ];
+
+  test('returns order for matching field', () => {
+    expect(getDefaultSortOrder('name', sorters)).toBe('asc');
+    expect(getDefaultSortOrder('createdAt', sorters)).toBe('desc');
+  });
+
+  test('returns undefined for non-matching field', () => {
+    expect(getDefaultSortOrder('unknown', sorters)).toBeUndefined();
+  });
+
+  test('returns undefined for empty/undefined sorters', () => {
+    expect(getDefaultSortOrder('name', undefined)).toBeUndefined();
+    expect(getDefaultSortOrder('name', [])).toBeUndefined();
+  });
+});
+
+// ─── unionFilters ─────────────────────────────────────────────
+
+describe('unionFilters', () => {
+  test('merges new filters over previous', () => {
+    const prev: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'draft' },
+    ];
+    const next: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'published' },
+    ];
+    const result = unionFilters([], next, prev);
+    expect(result).toHaveLength(1);
+    expect(result[0].value).toBe('published');
+  });
+
+  test('permanent filters override everything', () => {
+    const permanent: Filter[] = [
+      { field: 'org', operator: 'eq', value: 'acme' },
+    ];
+    const next: Filter[] = [
+      { field: 'org', operator: 'eq', value: 'other' },
+    ];
+    const result = unionFilters(permanent, next, []);
+    expect(result).toHaveLength(1);
+    expect(result[0].value).toBe('acme');
+  });
+
+  test('removes filters with undefined value', () => {
+    const prev: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'draft' },
+    ];
+    const next: Filter[] = [
+      { field: 'status', operator: 'eq', value: undefined },
+    ];
+    const result = unionFilters([], next, prev);
+    expect(result).toHaveLength(0);
+  });
+
+  test('adds new filters not in previous', () => {
+    const prev: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'draft' },
+    ];
+    const next: Filter[] = [
+      { field: 'category', operator: 'eq', value: 'tech' },
+    ];
+    const result = unionFilters([], next, prev);
+    expect(result).toHaveLength(2);
+  });
+
+  test('handles empty arrays', () => {
+    expect(unionFilters([], [], [])).toEqual([]);
+  });
+});
+
+// ─── unionSorters ─────────────────────────────────────────────
+
+describe('unionSorters', () => {
+  test('new sorters take priority', () => {
+    const permanent: Sort[] = [{ field: 'id', order: 'asc' }];
+    const newSorters: Sort[] = [{ field: 'name', order: 'desc' }];
+    const result = unionSorters(permanent, newSorters);
+    expect(result).toHaveLength(2);
+    expect(result[0].field).toBe('name');
+  });
+
+  test('permanent sorters are not duplicated', () => {
+    const permanent: Sort[] = [{ field: 'name', order: 'asc' }];
+    const newSorters: Sort[] = [{ field: 'name', order: 'desc' }];
+    const result = unionSorters(permanent, newSorters);
+    expect(result).toHaveLength(1);
+    expect(result[0].order).toBe('desc');
+  });
+
+  test('empty arrays', () => {
+    expect(unionSorters([], [])).toEqual([]);
+  });
+});
+
+// ─── parseCSV ─────────────────────────────────────────────────
+
+describe('parseCSV', () => {
+  test('parses simple CSV', () => {
+    const rows = parseCSV('name,age\nAlice,30\nBob,25');
+    expect(rows).toHaveLength(3);
+    expect(rows[0]).toEqual(['name', 'age']);
+    expect(rows[1]).toEqual(['Alice', '30']);
+    expect(rows[2]).toEqual(['Bob', '25']);
+  });
+
+  test('handles quoted fields', () => {
+    const rows = parseCSV('name,bio\nAlice,"Hello, World"');
+    expect(rows).toHaveLength(2);
+    expect(rows[1][1]).toBe('Hello, World');
+  });
+
+  test('handles escaped quotes', () => {
+    const rows = parseCSV('val\n"He said ""hello"""');
+    expect(rows).toHaveLength(2);
+    expect(rows[1][0]).toBe('He said "hello"');
+  });
+
+  test('handles CRLF line endings', () => {
+    const rows = parseCSV('a,b\r\n1,2\r\n3,4');
+    expect(rows).toHaveLength(3);
+  });
+
+  test('skips empty rows', () => {
+    const rows = parseCSV('a\n\nb\n');
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toEqual(['a']);
+    expect(rows[1]).toEqual(['b']);
+  });
+
+  test('handles empty input', () => {
+    expect(parseCSV('')).toEqual([]);
+  });
+});

package/src/helpers.ts

@@ -4,122 +4,13 @@ import type { Filter, Sort, CrudOperator } from './types';
 import { t } from './i18n.svelte';
 import { getTextTransformers } from './options.svelte';
 
-// ─── Table Helpers ────────────────────────────────────────────
+// ─── Re-export pure utilities (testable without Svelte runtime) ───
+export {
+  getDefaultFilter, getDefaultSortOrder,
+  unionFilters, unionSorters,
+  file2Base64, parseCSV,
+} from './helpers-pure';
 
-/**
- * Get the current filter value for a field from a filter array.
- * Useful for setting default values in filter inputs.
- */
-export function getDefaultFilter(
-  columnName: string,
-  filters?: Filter[],
-  operatorType: CrudOperator = 'eq',
-): unknown | undefined {
-  if (!filters) return undefined;
-  const filter = filters.find((f) => {
-    if ('field' in f) {
-      return f.field === columnName && f.operator === operatorType;
-    }
-    return false;
-  });
-  return filter && 'value' in filter ? filter.value : undefined;
-}
-
-/**
- * Get the current sort order for a field from a sorter array.
- * Returns 'asc', 'desc', or undefined.
- */
-export function getDefaultSortOrder(
-  columnName: string,
-  sorters?: Sort[],
-): 'asc' | 'desc' | undefined {
-  if (!sorters) return undefined;
-  const sortItem = sorters.find((item) => item.field === columnName);
-  return sortItem?.order as 'asc' | 'desc' | undefined;
-}
-
-/**
- * Merge two filter arrays, deduplicating by field+operator.
- * Filters in `newFilters` take priority over `prevFilters`.
- * `permanentFilter` items are always preserved.
- * Filters with undefined values are removed from the result.
- */
-export function unionFilters(
-  permanentFilter: Filter[],
-  newFilters: Filter[],
-  prevFilters: Filter[] = [],
-): Filter[] {
-  const compareFilters = (a: Filter, b: Filter): boolean => {
-    if ('field' in a && 'field' in b) {
-      return a.field === b.field && a.operator === b.operator;
-    }
-    return false;
-  };
-
-  // Start with previous filters
-  let result = [...prevFilters];
-
-  // Apply new filters (override previous by field+operator)
-  for (const newFilter of newFilters) {
-    const idx = result.findIndex((f) => compareFilters(f, newFilter));
-    if (idx >= 0) {
-      result[idx] = newFilter;
-    } else {
-      result.push(newFilter);
-    }
-  }
-
-  // Ensure permanent filters are always present
-  for (const perm of permanentFilter) {
-    const idx = result.findIndex((f) => compareFilters(f, perm));
-    if (idx >= 0) {
-      result[idx] = perm;
-    } else {
-      result.push(perm);
-    }
-  }
-
-  // Remove filters with undefined values
-  return result.filter((f) => !('value' in f && f.value === undefined));
-}
-
-/**
- * Merge two sorter arrays, deduplicating by field.
- * Sorters in `newSorters` take priority.
- */
-export function unionSorters(
-  permanentSorters: Sort[],
-  newSorters: Sort[],
-): Sort[] {
-  const result = [...newSorters];
-
-  for (const perm of permanentSorters) {
-    if (!result.some((s) => s.field === perm.field)) {
-      result.push(perm);
-    }
-  }
-
-  return result;
-}
-
-// ─── Upload Helpers ───────────────────────────────────────────
-
-/**
- * Convert a File (or file-like object) to a base64 data URL string.
- * Useful for image uploads and previews.
- */
-export function file2Base64(file: File | { uid?: string } & Blob): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.readAsDataURL(file as Blob);
-    reader.addEventListener('load', () => {
-      resolve(reader.result as string);
-    });
-    reader.addEventListener('error', () => {
-      reject(reader.error);
-    });
-  });
-}
 
 // ─── Document Title Helper ────────────────────────────────────
 
@@ -219,7 +110,7 @@ export function deriveValidator(
         case 'email': {
           const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
           if (typeof value === 'string' && !emailRegex.test(value)) {
-            errors[field.key] = t('validation.email', { defaultValue: 'Invalid email address' });
+            errors[field.key] = t('validation.invalidEmail');
           }
           break;
         }
@@ -227,13 +118,13 @@ export function deriveValidator(
           try {
             new URL(value as string);
           } catch {
-            errors[field.key] = t('validation.url', { defaultValue: 'Invalid URL' });
+            errors[field.key] = t('validation.invalidUrl');
           }
           break;
         }
         case 'number': {
           if (typeof value === 'string' && isNaN(Number(value))) {
-            errors[field.key] = t('validation.number', { defaultValue: 'Must be a number' });
+            errors[field.key] = t('validation.invalidNumber');
           }
           break;
         }

package/src/hook-utils.svelte.ts

@@ -3,7 +3,27 @@
 
 import { useQueryClient } from '@tanstack/svelte-query';
 import type { LiveProvider, LiveEvent, LiveMode } from './live.svelte';
-import { toast } from './toast.svelte';
+import { getAuthProvider } from './context.svelte';
+import { notify } from './notification.svelte';
+
+// ─── Auth Error Delegate ────────────────────────────────────────
+// Delegate auth errors (401/403) to authProvider.onError() — refine pattern
+
+export async function checkError(error: unknown): Promise<void> {
+  try {
+    const authProvider = getAuthProvider({ optional: true });
+    if (!authProvider?.onError) return;
+    const result = await authProvider.onError(error);
+    if (result.logout) {
+      await authProvider.logout?.();
+      const { navigate } = await import('./router');
+      navigate(result.redirectTo ?? '/login');
+    } else if (result.redirectTo) {
+      const { navigate } = await import('./router');
+      navigate(result.redirectTo);
+    }
+  } catch { /* auth check failed silently */ }
+}
 
 // ─── Overtime Tracker ───────────────────────────────────────────
 // Tracks elapsed time during loading, auto-cleans via $effect
@@ -71,7 +91,7 @@ export function createLiveSubscription(paramsFn: () => LiveSubscriptionParams):
       callback: (event: LiveEvent) => {
         params.onLiveEvent?.(event);
         if (liveMode === 'auto') {
-          queryClient.invalidateQueries({ queryKey: [params.resource] });
+          queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === params.resource });
         }
       },
     });
@@ -98,10 +118,10 @@ export function fireSuccessNotification(
   if (!config && !defaultMessage) return;
   if (typeof config === 'function') {
     const result = config(data, values, resource);
-    toast.success(result.message);
+    notify({ type: 'success', message: result.message, description: result.description });
     return;
   }
-  toast.success(config || defaultMessage);
+  notify({ type: 'success', message: config || defaultMessage });
 }
 
 export function fireErrorNotification(
@@ -110,11 +130,12 @@ export function fireErrorNotification(
   error?: unknown,
 ): void {
   if (config === false) return;
+  if (!config && !defaultMessage) return;
   if (typeof config === 'function') {
     const result = config(error);
-    toast.error(result.message);
+    notify({ type: 'error', message: result.message, description: result.description });
     return;
   }
   const errMsg = error instanceof Error ? error.message : String(error ?? '');
-  toast.error(config || `${defaultMessage}${errMsg ? ': ' + errMsg : ''}`);
+  notify({ type: 'error', message: config || `${defaultMessage}${errMsg ? ': ' + errMsg : ''}` });
 }