@object-ui/react 3.3.0 → 3.3.2

package/src/hooks/__tests__/useActionEngine.test.ts

@@ -1,170 +0,0 @@
-/**
- * Tests for useActionEngine hook
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useActionEngine } from '../useActionEngine';
-
-describe('useActionEngine', () => {
-  const sampleActions = [
-    {
-      name: 'mark_complete',
-      type: 'script',
-      execute: 'true',
-      locations: ['list_toolbar', 'record_header'],
-      bulkEnabled: true,
-    },
-    {
-      name: 'delete_record',
-      type: 'api',
-      endpoint: '/api/delete',
-      locations: ['record_more'],
-    },
-    {
-      name: 'view_details',
-      type: 'url',
-      target: '/details',
-      locations: ['list_item'],
-    },
-    {
-      name: 'global_search',
-      type: 'script',
-      execute: 'true',
-      locations: ['global_nav'],
-      shortcut: 'ctrl+k',
-    },
-  ];
-
-  describe('getActionsForLocation', () => {
-    it('returns actions for list_toolbar', () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      const actions = result.current.getActionsForLocation('list_toolbar');
-      expect(actions.length).toBe(1);
-      expect(actions[0].name).toBe('mark_complete');
-    });
-
-    it('returns actions for record_header', () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      const actions = result.current.getActionsForLocation('record_header');
-      expect(actions.length).toBe(1);
-      expect(actions[0].name).toBe('mark_complete');
-    });
-
-    it('returns actions for record_more', () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      const actions = result.current.getActionsForLocation('record_more');
-      expect(actions.length).toBe(1);
-      expect(actions[0].name).toBe('delete_record');
-    });
-
-    it('returns empty array for location with no actions', () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      const actions = result.current.getActionsForLocation('record_related');
-      expect(actions.length).toBe(0);
-    });
-  });
-
-  describe('getBulkActions', () => {
-    it('returns only bulk-enabled actions', () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      const bulkActions = result.current.getBulkActions();
-      expect(bulkActions.length).toBe(1);
-      expect(bulkActions[0].name).toBe('mark_complete');
-    });
-  });
-
-  describe('executeAction', () => {
-    it('executes a registered action by name', async () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      let actionResult: any;
-      await act(async () => {
-        actionResult = await result.current.executeAction('mark_complete');
-      });
-
-      expect(actionResult.success).toBe(true);
-    });
-
-    it('returns error for unregistered action', async () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      let actionResult: any;
-      await act(async () => {
-        actionResult = await result.current.executeAction('nonexistent');
-      });
-
-      expect(actionResult.success).toBe(false);
-      expect(actionResult.error).toContain('not found');
-    });
-  });
-
-  describe('handleShortcut', () => {
-    it('handles registered keyboard shortcut', async () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      let shortcutResult: any;
-      await act(async () => {
-        shortcutResult = await result.current.handleShortcut('ctrl+k');
-      });
-
-      expect(shortcutResult).not.toBeNull();
-      expect(shortcutResult.success).toBe(true);
-    });
-
-    it('returns null for unregistered shortcut', async () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: sampleActions }),
-      );
-
-      let shortcutResult: any;
-      await act(async () => {
-        shortcutResult = await result.current.handleShortcut('ctrl+z');
-      });
-
-      expect(shortcutResult).toBeNull();
-    });
-  });
-
-  describe('defaults', () => {
-    it('works with no options', () => {
-      const { result } = renderHook(() => useActionEngine());
-
-      expect(result.current.engine).toBeDefined();
-      expect(typeof result.current.getActionsForLocation).toBe('function');
-      expect(typeof result.current.getBulkActions).toBe('function');
-      expect(typeof result.current.executeAction).toBe('function');
-      expect(typeof result.current.handleShortcut).toBe('function');
-    });
-
-    it('works with empty actions array', () => {
-      const { result } = renderHook(() =>
-        useActionEngine({ actions: [] }),
-      );
-
-      const actions = result.current.getActionsForLocation('list_toolbar');
-      expect(actions).toEqual([]);
-    });
-  });
-});

package/src/hooks/__tests__/useActionRunner.test.ts

@@ -1,153 +0,0 @@
-/**
- * Tests for useActionRunner hook
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, waitFor, act } from '@testing-library/react';
-import { useActionRunner } from '../useActionRunner';
-
-describe('useActionRunner', () => {
-  it('returns initial state with loading=false, error=null, result=null', () => {
-    const { result } = renderHook(() => useActionRunner());
-
-    expect(result.current.loading).toBe(false);
-    expect(result.current.error).toBeNull();
-    expect(result.current.result).toBeNull();
-  });
-
-  it('exposes runner, execute, and updateContext', () => {
-    const { result } = renderHook(() => useActionRunner());
-
-    expect(result.current.runner).toBeDefined();
-    expect(typeof result.current.execute).toBe('function');
-    expect(typeof result.current.updateContext).toBe('function');
-  });
-
-  it('handles options with context key format', () => {
-    const { result } = renderHook(() =>
-      useActionRunner({ context: { data: { name: 'test' } } }),
-    );
-
-    expect(result.current.runner).toBeDefined();
-    expect(result.current.loading).toBe(false);
-  });
-
-  it('handles plain context object format (backwards compat)', () => {
-    const { result } = renderHook(() =>
-      useActionRunner({ data: { name: 'test' } }),
-    );
-
-    expect(result.current.runner).toBeDefined();
-    expect(result.current.loading).toBe(false);
-  });
-
-  it('sets loading=true during execution and loading=false after', async () => {
-    let resolveAction: () => void;
-    const pendingAction = new Promise<void>((resolve) => {
-      resolveAction = resolve;
-    });
-
-    const { result } = renderHook(() => useActionRunner());
-
-    let executePromise: Promise<unknown>;
-    act(() => {
-      executePromise = result.current.execute({
-        onClick: () => pendingAction,
-      });
-    });
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(true);
-    });
-
-    await act(async () => {
-      resolveAction!();
-      await executePromise;
-    });
-
-    expect(result.current.loading).toBe(false);
-  });
-
-  it('sets result on successful action execution', async () => {
-    const onNavigate = vi.fn();
-    const { result } = renderHook(() =>
-      useActionRunner({ context: {}, onNavigate }),
-    );
-
-    await act(async () => {
-      await result.current.execute({
-        type: 'navigation',
-        navigate: { to: '/dashboard' },
-      });
-    });
-
-    expect(result.current.result).toEqual({ success: true });
-    expect(result.current.error).toBeNull();
-    expect(result.current.loading).toBe(false);
-    expect(onNavigate).toHaveBeenCalledWith(
-      '/dashboard',
-      expect.objectContaining({ external: false }),
-    );
-  });
-
-  it('sets error on failed action execution (catch path)', async () => {
-    const { result } = renderHook(() => useActionRunner());
-
-    await act(async () => {
-      await result.current.execute({
-        onClick: () => {
-          throw new Error('Something went wrong');
-        },
-      });
-    });
-
-    expect(result.current.error).toBe('Something went wrong');
-    expect(result.current.result).toEqual({
-      success: false,
-      error: 'Something went wrong',
-    });
-    expect(result.current.loading).toBe(false);
-  });
-
-  it('updateContext calls runner.updateContext', () => {
-    const { result } = renderHook(() => useActionRunner());
-
-    const spy = vi.spyOn(result.current.runner, 'updateContext');
-
-    act(() => {
-      result.current.updateContext({ data: { id: 42 } });
-    });
-
-    expect(spy).toHaveBeenCalledWith({ data: { id: 42 } });
-  });
-
-  it('accepts handler options (onToast, onNavigate, etc.)', async () => {
-    const onToast = vi.fn();
-    const onNavigate = vi.fn();
-
-    const { result } = renderHook(() =>
-      useActionRunner({
-        context: {},
-        onToast,
-        onNavigate,
-      }),
-    );
-
-    await act(async () => {
-      await result.current.execute({
-        type: 'navigation',
-        navigate: { to: '/settings' },
-        successMessage: 'Navigated!',
-      });
-    });
-
-    expect(onNavigate).toHaveBeenCalledWith(
-      '/settings',
-      expect.objectContaining({ external: false }),
-    );
-    expect(onToast).toHaveBeenCalledWith(
-      'Navigated!',
-      expect.objectContaining({ type: 'success' }),
-    );
-  });
-});

package/src/hooks/__tests__/useAnimation.test.ts

@@ -1,82 +0,0 @@
-/**
- * Tests for useAnimation and useReducedMotion hooks
- */
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useAnimation } from '../useAnimation';
-import { useReducedMotion } from '../useReducedMotion';
-
-describe('useAnimation', () => {
-  it('returns empty className and style for no config', () => {
-    const { result } = renderHook(() => useAnimation());
-    expect(result.current.className).toBe('');
-    expect(result.current.style).toEqual({});
-  });
-
-  it('returns empty when preset is none', () => {
-    const { result } = renderHook(() => useAnimation({ preset: 'none' }));
-    expect(result.current.className).toBe('');
-  });
-
-  it('returns empty when disabled', () => {
-    const { result } = renderHook(() =>
-      useAnimation({ preset: 'fade', enabled: false })
-    );
-    expect(result.current.className).toBe('');
-  });
-
-  it('returns correct className for fade preset', () => {
-    const { result } = renderHook(() => useAnimation({ preset: 'fade' }));
-    expect(result.current.className).toContain('fade-in');
-  });
-
-  it('returns correct className for slide-up preset', () => {
-    const { result } = renderHook(() => useAnimation({ preset: 'slide-up' }));
-    expect(result.current.className).toContain('slide-in-from-bottom');
-  });
-
-  it('returns correct className for scale preset', () => {
-    const { result } = renderHook(() => useAnimation({ preset: 'scale' }));
-    expect(result.current.className).toContain('zoom-in');
-  });
-
-  it('returns correct className for scale-fade preset', () => {
-    const { result } = renderHook(() => useAnimation({ preset: 'scale-fade' }));
-    expect(result.current.className).toContain('fade-in');
-    expect(result.current.className).toContain('zoom-in');
-  });
-
-  it('applies custom duration', () => {
-    const { result } = renderHook(() =>
-      useAnimation({ preset: 'fade', duration: 300 })
-    );
-    expect(result.current.style.animationDuration).toBe('300ms');
-  });
-
-  it('applies custom delay', () => {
-    const { result } = renderHook(() =>
-      useAnimation({ preset: 'fade', delay: 100 })
-    );
-    expect(result.current.style.animationDelay).toBe('100ms');
-  });
-
-  it('applies easing function', () => {
-    const { result } = renderHook(() =>
-      useAnimation({ preset: 'fade', easing: 'spring' })
-    );
-    expect(result.current.style.animationTimingFunction).toContain('cubic-bezier');
-  });
-});
-
-describe('useReducedMotion', () => {
-  it('returns a boolean value', () => {
-    const { result } = renderHook(() => useReducedMotion());
-    expect(typeof result.current).toBe('boolean');
-  });
-
-  it('defaults to false when matchMedia returns false', () => {
-    const { result } = renderHook(() => useReducedMotion());
-    // jsdom matchMedia always returns false by default
-    expect(result.current).toBe(false);
-  });
-});

package/src/hooks/__tests__/useColumnSummary.test.ts

@@ -1,93 +0,0 @@
-/**
- * Tests for useColumnSummary hook
- */
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useColumnSummary } from '../useColumnSummary';
-
-const sampleData = [
-  { name: 'Alice', amount: 100, category: 'A' },
-  { name: 'Bob', amount: 200, category: 'B' },
-  { name: 'Charlie', amount: 300, category: 'A' },
-  { name: 'Diana', amount: 400, category: 'C' },
-];
-
-describe('useColumnSummary', () => {
-  it('computes sum correctly', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'sum' })
-    );
-    expect(result.current.value).toBe(1000);
-    expect(result.current.label).toBe('SUM');
-  });
-
-  it('computes avg correctly', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'avg' })
-    );
-    expect(result.current.value).toBe(250);
-  });
-
-  it('computes count correctly', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'count' })
-    );
-    expect(result.current.value).toBe(4);
-  });
-
-  it('computes min correctly', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'min' })
-    );
-    expect(result.current.value).toBe(100);
-  });
-
-  it('computes max correctly', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'max' })
-    );
-    expect(result.current.value).toBe(400);
-  });
-
-  it('computes distinct correctly', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'category', function: 'distinct' })
-    );
-    expect(result.current.value).toBe(3); // A, B, C
-  });
-
-  it('uses custom label', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'sum', label: 'Total Revenue' })
-    );
-    expect(result.current.label).toBe('Total Revenue');
-  });
-
-  it('returns formatted string', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary(sampleData, { field: 'amount', function: 'sum' }, 'en-US')
-    );
-    expect(result.current.formatted).toBe('1,000');
-  });
-
-  it('handles empty data for sum', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary([], { field: 'amount', function: 'sum' })
-    );
-    expect(result.current.value).toBe(0);
-  });
-
-  it('handles empty data for avg', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary([], { field: 'amount', function: 'avg' })
-    );
-    expect(result.current.value).toBe(0);
-  });
-
-  it('handles empty data for min', () => {
-    const { result } = renderHook(() =>
-      useColumnSummary([], { field: 'amount', function: 'min' })
-    );
-    expect(result.current.value).toBe(0);
-  });
-});

package/src/hooks/__tests__/useCrudShortcuts.test.ts

@@ -1,85 +0,0 @@
-/**
- * Tests for useCrudShortcuts hook
- */
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useCrudShortcuts } from '../useCrudShortcuts';
-
-describe('useCrudShortcuts', () => {
-  it('renders without error with empty callbacks', () => {
-    expect(() => {
-      renderHook(() => useCrudShortcuts({}));
-    }).not.toThrow();
-  });
-
-  it('renders without error when disabled', () => {
-    expect(() => {
-      renderHook(() => useCrudShortcuts({}, false));
-    }).not.toThrow();
-  });
-
-  it('registers onCreate shortcut', () => {
-    const onCreate = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onCreate }));
-    }).not.toThrow();
-  });
-
-  it('registers onEdit shortcut', () => {
-    const onEdit = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onEdit }));
-    }).not.toThrow();
-  });
-
-  it('registers onDelete shortcut', () => {
-    const onDelete = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onDelete }));
-    }).not.toThrow();
-  });
-
-  it('registers onSave shortcut', () => {
-    const onSave = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onSave }));
-    }).not.toThrow();
-  });
-
-  it('registers onDuplicate shortcut', () => {
-    const onDuplicate = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onDuplicate }));
-    }).not.toThrow();
-  });
-
-  it('registers onCancel shortcut', () => {
-    const onCancel = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onCancel }));
-    }).not.toThrow();
-  });
-
-  it('registers onSearch shortcut', () => {
-    const onSearch = vi.fn();
-    expect(() => {
-      renderHook(() => useCrudShortcuts({ onSearch }));
-    }).not.toThrow();
-  });
-
-  it('registers all shortcuts together', () => {
-    expect(() => {
-      renderHook(() =>
-        useCrudShortcuts({
-          onCreate: vi.fn(),
-          onEdit: vi.fn(),
-          onDelete: vi.fn(),
-          onSave: vi.fn(),
-          onDuplicate: vi.fn(),
-          onCancel: vi.fn(),
-          onSearch: vi.fn(),
-        })
-      );
-    }).not.toThrow();
-  });
-});

package/src/hooks/__tests__/useDataRefresh.test.ts

@@ -1,115 +0,0 @@
-/**
- * ObjectUI — useDataRefresh Tests
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * Tests for the reusable data-refresh hook (P1/P2).
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useDataRefresh } from '../useDataRefresh';
-
-describe('useDataRefresh', () => {
-  it('should return refreshKey=0 and a refresh function', () => {
-    const { result } = renderHook(() => useDataRefresh(undefined, undefined));
-
-    expect(result.current.refreshKey).toBe(0);
-    expect(typeof result.current.refresh).toBe('function');
-  });
-
-  it('should increment refreshKey when refresh() is called', () => {
-    const { result } = renderHook(() => useDataRefresh(undefined, 'contacts'));
-
-    act(() => {
-      result.current.refresh();
-    });
-
-    expect(result.current.refreshKey).toBe(1);
-
-    act(() => {
-      result.current.refresh();
-    });
-
-    expect(result.current.refreshKey).toBe(2);
-  });
-
-  it('should auto-subscribe to DataSource.onMutation() when available', () => {
-    let listener: ((event: any) => void) | null = null;
-    const unsub = vi.fn();
-    const ds: any = {
-      onMutation: vi.fn((cb: any) => {
-        listener = cb;
-        return unsub;
-      }),
-    };
-
-    const { result } = renderHook(() => useDataRefresh(ds, 'contacts'));
-
-    expect(ds.onMutation).toHaveBeenCalledOnce();
-
-    // Simulate a mutation on the same resource
-    act(() => {
-      listener?.({ type: 'create', resource: 'contacts' });
-    });
-
-    expect(result.current.refreshKey).toBe(1);
-  });
-
-  it('should NOT increment refreshKey for mutations on a different resource', () => {
-    let listener: ((event: any) => void) | null = null;
-    const ds: any = {
-      onMutation: vi.fn((cb: any) => {
-        listener = cb;
-        return vi.fn();
-      }),
-    };
-
-    const { result } = renderHook(() => useDataRefresh(ds, 'contacts'));
-
-    act(() => {
-      listener?.({ type: 'create', resource: 'accounts' });
-    });
-
-    expect(result.current.refreshKey).toBe(0);
-  });
-
-  it('should unsubscribe on unmount', () => {
-    const unsub = vi.fn();
-    const ds: any = {
-      onMutation: vi.fn(() => unsub),
-    };
-
-    const { unmount } = renderHook(() => useDataRefresh(ds, 'contacts'));
-
-    expect(unsub).not.toHaveBeenCalled();
-
-    unmount();
-
-    expect(unsub).toHaveBeenCalledOnce();
-  });
-
-  it('should work without onMutation (backward compatible)', () => {
-    const ds: any = {
-      find: vi.fn(),
-    };
-
-    const { result } = renderHook(() => useDataRefresh(ds, 'contacts'));
-
-    expect(result.current.refreshKey).toBe(0);
-    // Should not throw
-    act(() => {
-      result.current.refresh();
-    });
-    expect(result.current.refreshKey).toBe(1);
-  });
-
-  it('should skip subscription when objectName is undefined', () => {
-    const ds: any = {
-      onMutation: vi.fn(() => vi.fn()),
-    };
-
-    renderHook(() => useDataRefresh(ds, undefined));
-
-    expect(ds.onMutation).not.toHaveBeenCalled();
-  });
-});