@svadmin/core 0.25.2 → 0.25.3

package/src/data-transfer.test.ts

@@ -1,118 +0,0 @@
-// Unit tests for CSV parsing and data-transfer utilities
-import { describe, test, expect } from 'bun:test';
-
-// We test parseCSVLine directly by re-implementing the exported logic
-// since the function is not exported. We test the CSV format contract.
-
-function parseCSVLine(line: string): string[] {
-  const result: string[] = [];
-  let current = '';
-  let inQuotes = false;
-
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if (inQuotes) {
-      if (ch === '"' && line[i + 1] === '"') {
-        current += '"';
-        i++;
-      } else if (ch === '"') {
-        inQuotes = false;
-      } else {
-        current += ch;
-      }
-    } else {
-      if (ch === '"') {
-        inQuotes = true;
-      } else if (ch === ',') {
-        result.push(current.trim());
-        current = '';
-      } else {
-        current += ch;
-      }
-    }
-  }
-  result.push(current.trim());
-  return result;
-}
-
-describe('parseCSVLine', () => {
-  test('simple comma-separated values', () => {
-    expect(parseCSVLine('a,b,c')).toEqual(['a', 'b', 'c']);
-  });
-
-  test('values with whitespace are trimmed', () => {
-    expect(parseCSVLine(' hello , world , test ')).toEqual(['hello', 'world', 'test']);
-  });
-
-  test('quoted values preserve commas', () => {
-    expect(parseCSVLine('"hello, world",b,c')).toEqual(['hello, world', 'b', 'c']);
-  });
-
-  test('escaped quotes inside quoted values', () => {
-    expect(parseCSVLine('"say ""hello""",b')).toEqual(['say "hello"', 'b']);
-  });
-
-  test('empty values', () => {
-    expect(parseCSVLine('a,,c')).toEqual(['a', '', 'c']);
-  });
-
-  test('single value', () => {
-    expect(parseCSVLine('hello')).toEqual(['hello']);
-  });
-
-  test('empty line', () => {
-    expect(parseCSVLine('')).toEqual(['']);
-  });
-
-  test('quoted value with newline character', () => {
-    expect(parseCSVLine('"line1\nline2",b')).toEqual(['line1\nline2', 'b']);
-  });
-
-  test('mixed quoted and unquoted', () => {
-    expect(parseCSVLine('1,"John Doe","admin@test.com",true')).toEqual([
-      '1', 'John Doe', 'admin@test.com', 'true'
-    ]);
-  });
-});
-
-// CSV row formatting (escape logic from useExport)
-function escapeCSVField(val: unknown): string {
-  const str = val === null || val === undefined ? '' : String(val);
-  return str.includes(',') || str.includes('"') || str.includes('\n')
-    ? `"${str.replace(/"/g, '""')}"`
-    : str;
-}
-
-describe('escapeCSVField', () => {
-  test('simple string passes through', () => {
-    expect(escapeCSVField('hello')).toBe('hello');
-  });
-
-  test('null becomes empty string', () => {
-    expect(escapeCSVField(null)).toBe('');
-  });
-
-  test('undefined becomes empty string', () => {
-    expect(escapeCSVField(undefined)).toBe('');
-  });
-
-  test('string with comma is quoted', () => {
-    expect(escapeCSVField('hello, world')).toBe('"hello, world"');
-  });
-
-  test('string with double quote is escaped', () => {
-    expect(escapeCSVField('say "hi"')).toBe('"say ""hi"""');
-  });
-
-  test('string with newline is quoted', () => {
-    expect(escapeCSVField('line1\nline2')).toBe('"line1\nline2"');
-  });
-
-  test('number is converted to string', () => {
-    expect(escapeCSVField(42)).toBe('42');
-  });
-
-  test('boolean is converted to string', () => {
-    expect(escapeCSVField(true)).toBe('true');
-  });
-});

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

@@ -1,83 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { useForm } from './form-hooks.svelte';
-import { flushSync } from 'svelte';
-import { QueryClient } from '@tanstack/svelte-query';
-
-vi.mock('./context.svelte', () => ({
-  useDataProvider: () => ({
-    getOne: vi.fn(),
-    create: vi.fn().mockResolvedValue({ data: { id: 1 } }),
-    update: vi.fn().mockResolvedValue({ data: { id: 1 } })
-  }),
-  useResource: () => ({ name: 'posts' }),
-  getResource: () => ({ name: 'posts', primaryKey: 'id' }),
-  useRouterContext: () => ({ navigate: vi.fn() }),
-  useTranslate: () => (key: string) => key,
-  useNotification: () => ({ open: vi.fn(), close: vi.fn() })
-}));
-
-vi.mock('@tanstack/svelte-query', async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual as any,
-    useQueryClient: () => new QueryClient(),
-    createQuery: () => ({ data: { data: { id: 1, title: 'Original' } }, isPending: false }),
-    createMutation: (opts: any) => ({
-      mutate: vi.fn((vars, callbacks) => {
-        if (opts.mutationFn) opts.mutationFn(vars);
-        if (callbacks?.onSuccess) callbacks.onSuccess({ data: {} });
-      }),
-      isPending: false
-    })
-  };
-});
-
-describe('useForm - Headless Svelte 5 Compatibility', () => {
-
-  it('preserves reactive proxy data bindings safely across Svelte boundaries', () => {
-    let form: ReturnType<typeof useForm>;
-
-    const cleanup = $effect.root(() => {
-      form = useForm({
-        action: 'create',
-        resource: 'posts'
-      });
-    });
-
-    flushSync();
-    
-    // Properly use setFieldValue which guarantees state sync in svadmin forms
-    form!.setFieldValue('title', 'Reactive Test');
-    
-    flushSync();
-    
-    // The internal $state proxy absorbs this mutation
-    expect(form!.values.title).toBe('Reactive Test');
-    
-    cleanup();
-  });
-
-  it('handles autoSave queuing correctly across reactive boundaries', () => {
-    let form: ReturnType<typeof useForm>;
-    
-    const cleanup = $effect.root(() => {
-      form = useForm({
-        action: 'edit',
-        resource: 'posts',
-        id: 1,
-        autoSave: { enabled: true, debounce: 0 }
-      });
-    });
-
-    flushSync();
-
-    form!.setFieldValue('title', 'Saved Title');
-    
-    flushSync();
-
-    expect(form!.mutation).toBeDefined();
-    expect((form!.mutation as any).isPending).toBeDefined();
-
-    cleanup();
-  });
-});

package/src/helpers.test.ts

@@ -1,177 +0,0 @@
-// 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 override new sorters on same field', () => {
-    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('asc');
-  });
-
-  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/http-error.test.ts

@@ -1,85 +0,0 @@
-// HttpError + CrudOperator + LogicalFilter tests
-import { describe, test, expect } from 'bun:test';
-import { HttpError } from './types';
-import type { CrudOperator, Filter, LogicalFilter } from './types';
-
-describe('HttpError', () => {
-  test('creates with message and statusCode', () => {
-    const err = new HttpError('Not Found', 404);
-    expect(err.message).toBe('Not Found');
-    expect(err.statusCode).toBe(404);
-    expect(err.name).toBe('HttpError');
-    expect(err.errors).toBeUndefined();
-  });
-
-  test('creates with validation errors', () => {
-    const err = new HttpError('Validation Failed', 422, {
-      email: ['Email is required', 'Email must be valid'],
-      name: 'Name is required',
-    });
-    expect(err.statusCode).toBe(422);
-    expect(err.errors!.email).toEqual(['Email is required', 'Email must be valid']);
-    expect(err.errors!.name).toBe('Name is required');
-  });
-
-  test('is instanceof Error', () => {
-    const err = new HttpError('Server Error', 500);
-    expect(err instanceof Error).toBe(true);
-    expect(err instanceof HttpError).toBe(true);
-  });
-});
-
-describe('CrudOperator types', () => {
-  test('all operators are valid', () => {
-    const operators: CrudOperator[] = [
-      'eq', 'ne', 'lt', 'gt', 'lte', 'gte',
-      'contains', 'ncontains',
-      'startswith', 'endswith',
-      'in', 'nin',
-      'null', 'nnull',
-      'between', 'nbetween',
-    ];
-    expect(operators).toHaveLength(16);
-  });
-
-  test('Filter uses CrudOperator', () => {
-    const filter: Filter = { field: 'name', operator: 'startswith', value: 'A' };
-    expect(filter.operator).toBe('startswith');
-  });
-
-  test('negation operators', () => {
-    const filters: Filter[] = [
-      { field: 'status', operator: 'ncontains', value: 'draft' },
-      { field: 'deleted_at', operator: 'nnull', value: null },
-      { field: 'category', operator: 'nin', value: [1, 2] },
-      { field: 'price', operator: 'nbetween', value: [100, 200] },
-    ];
-    expect(filters).toHaveLength(4);
-  });
-});
-
-describe('LogicalFilter', () => {
-  test('or combination', () => {
-    const logical: LogicalFilter = {
-      operator: 'or',
-      value: [
-        { field: 'status', operator: 'eq', value: 'published' },
-        { field: 'status', operator: 'eq', value: 'draft' },
-      ],
-    };
-    expect(logical.operator).toBe('or');
-    expect(logical.value).toHaveLength(2);
-  });
-
-  test('and combination', () => {
-    const logical: LogicalFilter = {
-      operator: 'and',
-      value: [
-        { field: 'price', operator: 'gte', value: 10 },
-        { field: 'price', operator: 'lte', value: 100 },
-      ],
-    };
-    expect(logical.operator).toBe('and');
-    expect(logical.value).toHaveLength(2);
-  });
-});

package/src/i18n.test.ts

@@ -1,90 +0,0 @@
-// Unit tests for URL parsing (useParsed logic)
-// We test the pure parsing logic directly since the hook itself uses Svelte runes.
-import { describe, test, expect } from 'bun:test';
-
-/**
- * Parse a hash-based URL into structured route info.
- * This mirrors the logic in useParsed.ts.
- */
-function parseHash(hash: string) {
-  const raw = hash.startsWith('#') ? hash.slice(1) : hash;
-  const [pathPart, queryPart] = raw.split('?');
-  const segments = pathPart.split('/').filter(Boolean);
-  
-  const params: Record<string, string> = {};
-  if (queryPart) {
-    for (const pair of queryPart.split('&')) {
-      const [k, v] = pair.split('=');
-      if (k) params[decodeURIComponent(k)] = decodeURIComponent(v ?? '');
-    }
-  }
-
-  return {
-    resource: segments[0],
-    action: segments[1],
-    id: segments[2],
-    params,
-  };
-}
-
-describe('parseHash (useParsed logic)', () => {
-  test('empty hash', () => {
-    const result = parseHash('');
-    expect(result.resource).toBeUndefined();
-    expect(result.action).toBeUndefined();
-    expect(result.id).toBeUndefined();
-    expect(result.params).toEqual({});
-  });
-
-  test('root hash', () => {
-    const result = parseHash('#/');
-    expect(result.resource).toBeUndefined();
-  });
-
-  test('resource only', () => {
-    const result = parseHash('#/posts');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBeUndefined();
-    expect(result.id).toBeUndefined();
-  });
-
-  test('resource and action', () => {
-    const result = parseHash('#/posts/create');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBe('create');
-  });
-
-  test('resource, action, and id', () => {
-    const result = parseHash('#/posts/edit/42');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBe('edit');
-    expect(result.id).toBe('42');
-  });
-
-  test('with query params', () => {
-    const result = parseHash('#/posts?page=2&sort=name');
-    expect(result.resource).toBe('posts');
-    expect(result.params.page).toBe('2');
-    expect(result.params.sort).toBe('name');
-  });
-
-  test('resource with action and query', () => {
-    const result = parseHash('#/posts/edit/5?tab=details');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBe('edit');
-    expect(result.id).toBe('5');
-    expect(result.params.tab).toBe('details');
-  });
-
-  test('encoded query params', () => {
-    const result = parseHash('#/search?q=hello%20world&filter=tag%3Djs');
-    expect(result.params.q).toBe('hello world');
-    expect(result.params.filter).toBe('tag=js');
-  });
-
-  test('login route', () => {
-    const result = parseHash('#/login');
-    expect(result.resource).toBe('login');
-    expect(result.action).toBeUndefined();
-  });
-});