@object-ui/react 3.1.5 → 3.3.1

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

@@ -1,81 +0,0 @@
-/**
- * Tests for useDensityMode hook
- */
-import { describe, it, expect } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useDensityMode } from '../useDensityMode';
-
-describe('useDensityMode', () => {
-  it('defaults to comfortable mode', () => {
-    const { result } = renderHook(() => useDensityMode());
-    expect(result.current.mode).toBe('comfortable');
-  });
-
-  it('accepts initial mode', () => {
-    const { result } = renderHook(() => useDensityMode('compact'));
-    expect(result.current.mode).toBe('compact');
-  });
-
-  it('provides correct row height for compact', () => {
-    const { result } = renderHook(() => useDensityMode('compact'));
-    expect(result.current.rowHeight).toBe(32);
-  });
-
-  it('provides correct row height for comfortable', () => {
-    const { result } = renderHook(() => useDensityMode('comfortable'));
-    expect(result.current.rowHeight).toBe(40);
-  });
-
-  it('provides correct row height for spacious', () => {
-    const { result } = renderHook(() => useDensityMode('spacious'));
-    expect(result.current.rowHeight).toBe(52);
-  });
-
-  it('provides padding classes', () => {
-    const { result } = renderHook(() => useDensityMode('compact'));
-    expect(result.current.paddingClass).toContain('py-1');
-    expect(result.current.paddingClass).toContain('px-2');
-  });
-
-  it('provides font size classes', () => {
-    const { result } = renderHook(() => useDensityMode('compact'));
-    expect(result.current.fontSizeClass).toBe('text-xs');
-  });
-
-  it('cycles through modes', () => {
-    const { result } = renderHook(() => useDensityMode('compact'));
-
-    act(() => {
-      result.current.cycle();
-    });
-    expect(result.current.mode).toBe('comfortable');
-
-    act(() => {
-      result.current.cycle();
-    });
-    expect(result.current.mode).toBe('spacious');
-
-    act(() => {
-      result.current.cycle();
-    });
-    expect(result.current.mode).toBe('compact');
-  });
-
-  it('allows setting mode directly', () => {
-    const { result } = renderHook(() => useDensityMode());
-
-    act(() => {
-      result.current.setMode('spacious');
-    });
-    expect(result.current.mode).toBe('spacious');
-  });
-
-  it('accepts custom row heights', () => {
-    const { result } = renderHook(() =>
-      useDensityMode('compact', {
-        rowHeights: { compact: 24, comfortable: 36, spacious: 48 },
-      })
-    );
-    expect(result.current.rowHeight).toBe(24);
-  });
-});

package/src/hooks/__tests__/useDiscovery.test.tsx

@@ -1,149 +0,0 @@
-/**
- * Tests for useDiscovery hook
- */
-
-import React from 'react';
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, waitFor } from '@testing-library/react';
-import { useDiscovery } from '../useDiscovery';
-import { SchemaRendererContext } from '../../context/SchemaRendererContext';
-
-function createWrapper(dataSource: any) {
-  return ({ children }: { children: React.ReactNode }) =>
-    React.createElement(
-      SchemaRendererContext.Provider,
-      { value: { dataSource } },
-      children,
-    );
-}
-
-describe('useDiscovery', () => {
-  it('returns isLoading false and null discovery when no context is provided', async () => {
-    const { result } = renderHook(() => useDiscovery());
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.discovery).toBeNull();
-    expect(result.current.error).toBeNull();
-  });
-
-  it('returns isLoading false and null discovery when dataSource has no getDiscovery method', async () => {
-    const dataSource = { someOtherMethod: vi.fn() };
-
-    const { result } = renderHook(() => useDiscovery(), {
-      wrapper: createWrapper(dataSource),
-    });
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.discovery).toBeNull();
-    expect(result.current.error).toBeNull();
-  });
-
-  it('successfully fetches discovery data from dataSource.getDiscovery()', async () => {
-    const discoveryData = {
-      name: 'test-server',
-      version: '1.0.0',
-      services: {
-        auth: { enabled: true, status: 'available' as const },
-        data: { enabled: true, status: 'available' as const },
-      },
-    };
-
-    const dataSource = {
-      getDiscovery: vi.fn().mockResolvedValue(discoveryData),
-    };
-
-    const { result } = renderHook(() => useDiscovery(), {
-      wrapper: createWrapper(dataSource),
-    });
-
-    expect(result.current.isLoading).toBe(true);
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.discovery).toEqual(discoveryData);
-    expect(result.current.error).toBeNull();
-    expect(dataSource.getDiscovery).toHaveBeenCalled();
-  });
-
-  it('handles errors from getDiscovery gracefully', async () => {
-    const dataSource = {
-      getDiscovery: vi.fn().mockRejectedValue(new Error('Network error')),
-    };
-
-    const { result } = renderHook(() => useDiscovery(), {
-      wrapper: createWrapper(dataSource),
-    });
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.discovery).toBeNull();
-    expect(result.current.error?.message).toBe('Network error');
-  });
-
-  it('isAuthEnabled defaults to true when no discovery', async () => {
-    const { result } = renderHook(() => useDiscovery());
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.isAuthEnabled).toBe(true);
-  });
-
-  it('isAuthEnabled reflects the auth service enabled state', async () => {
-    const discoveryData = {
-      services: {
-        auth: { enabled: false },
-      },
-    };
-
-    const dataSource = {
-      getDiscovery: vi.fn().mockResolvedValue(discoveryData),
-    };
-
-    const { result } = renderHook(() => useDiscovery(), {
-      wrapper: createWrapper(dataSource),
-    });
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.isAuthEnabled).toBe(false);
-  });
-
-  it('cleans up on unmount (cancelled flag)', async () => {
-    let resolveDiscovery: (value: any) => void;
-    const discoveryPromise = new Promise((resolve) => {
-      resolveDiscovery = resolve;
-    });
-
-    const dataSource = {
-      getDiscovery: vi.fn().mockReturnValue(discoveryPromise),
-    };
-
-    const { result, unmount } = renderHook(() => useDiscovery(), {
-      wrapper: createWrapper(dataSource),
-    });
-
-    expect(result.current.isLoading).toBe(true);
-
-    unmount();
-
-    // Resolve after unmount — state should not update
-    resolveDiscovery!({ name: 'late-response' });
-
-    // Discovery should remain null since the component was unmounted
-    expect(result.current.discovery).toBeNull();
-  });
-});

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

@@ -1,161 +0,0 @@
-/**
- * Tests for useDynamicApp hook
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { renderHook, waitFor, act } from '@testing-library/react';
-import { useDynamicApp } from '../useDynamicApp';
-
-describe('useDynamicApp', () => {
-  const staticConfig = {
-    name: 'crm',
-    label: 'CRM App',
-    objects: ['contact', 'account'],
-  };
-
-  it('returns static config when no adapter is provided', () => {
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm', staticConfig }),
-    );
-
-    expect(result.current.config).toEqual(staticConfig);
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.isServerConfig).toBe(false);
-  });
-
-  it('returns null config when neither adapter nor static config provided', () => {
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm' }),
-    );
-
-    expect(result.current.config).toBeNull();
-    expect(result.current.isLoading).toBe(false);
-  });
-
-  it('loads config from server adapter', async () => {
-    const serverConfig = { name: 'crm', label: 'CRM (Server)', objects: ['contact'] };
-    const adapter = {
-      getApp: vi.fn().mockResolvedValue(serverConfig),
-    };
-
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm', staticConfig, adapter }),
-    );
-
-    // Initially loading
-    expect(result.current.isLoading).toBe(true);
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.config).toEqual(serverConfig);
-    expect(result.current.isServerConfig).toBe(true);
-    expect(adapter.getApp).toHaveBeenCalledWith('crm');
-  });
-
-  it('falls back to static config when server returns null', async () => {
-    const adapter = {
-      getApp: vi.fn().mockResolvedValue(null),
-    };
-
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm', staticConfig, adapter }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.config).toEqual(staticConfig);
-    expect(result.current.isServerConfig).toBe(false);
-  });
-
-  it('falls back to static config on server error', async () => {
-    const adapter = {
-      getApp: vi.fn().mockRejectedValue(new Error('Network error')),
-    };
-
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm', staticConfig, adapter }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.config).toEqual(staticConfig);
-    expect(result.current.isServerConfig).toBe(false);
-    expect(result.current.error?.message).toBe('Network error');
-  });
-
-  it('skips loading when enabled is false', () => {
-    const adapter = {
-      getApp: vi.fn(),
-    };
-
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm', staticConfig, adapter, enabled: false }),
-    );
-
-    expect(result.current.config).toEqual(staticConfig);
-    expect(result.current.isLoading).toBe(false);
-    expect(adapter.getApp).not.toHaveBeenCalled();
-  });
-
-  it('refresh invalidates cache and re-fetches', async () => {
-    let callCount = 0;
-    const adapter = {
-      getApp: vi.fn().mockImplementation(async () => {
-        callCount++;
-        return { name: 'crm', version: callCount };
-      }),
-      invalidateCache: vi.fn(),
-    };
-
-    const { result } = renderHook(() =>
-      useDynamicApp({ appId: 'crm', adapter }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect((result.current.config as any).version).toBe(1);
-
-    await act(async () => {
-      await result.current.refresh();
-    });
-
-    expect(adapter.invalidateCache).toHaveBeenCalledWith('app:crm');
-    expect((result.current.config as any).version).toBe(2);
-  });
-
-  it('reloads when appId changes', async () => {
-    const adapter = {
-      getApp: vi.fn().mockImplementation(async (appId: string) => {
-        return { name: appId };
-      }),
-    };
-
-    const { result, rerender } = renderHook(
-      ({ appId }: { appId: string }) =>
-        useDynamicApp({ appId, adapter }),
-      { initialProps: { appId: 'crm' } },
-    );
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect((result.current.config as any).name).toBe('crm');
-
-    rerender({ appId: 'erp' });
-
-    await waitFor(() => {
-      expect((result.current.config as any).name).toBe('erp');
-    });
-
-    expect(adapter.getApp).toHaveBeenCalledWith('erp');
-  });
-});

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

@@ -1,153 +0,0 @@
-/**
- * Tests for useETagCache hook
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useETagCache } from '../useETagCache';
-
-describe('useETagCache', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    // Clear the module-scoped memory cache between tests
-    const { result } = renderHook(() => useETagCache());
-    act(() => {
-      result.current.clearCache();
-    });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('returns initial state with cacheSize: 0', () => {
-    const { result } = renderHook(() => useETagCache());
-
-    expect(result.current.cacheSize).toBe(0);
-    expect(result.current.serviceWorkerActive).toBe(false);
-    expect(result.current.fetchWithETag).toBeTypeOf('function');
-    expect(result.current.invalidate).toBeTypeOf('function');
-    expect(result.current.clearCache).toBeTypeOf('function');
-  });
-
-  it('fetchWithETag makes a network request and caches the response', async () => {
-    const mockData = { id: 1, name: 'Test' };
-    const mockHeaders = new Headers({ etag: '"abc123"' });
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      new Response(JSON.stringify(mockData), {
-        status: 200,
-        headers: mockHeaders,
-      }),
-    );
-
-    const { result } = renderHook(() => useETagCache());
-
-    let response: { data: unknown; fromCache: boolean; etag?: string } | undefined;
-    await act(async () => {
-      response = await result.current.fetchWithETag('/api/test');
-    });
-
-    expect(response!.data).toEqual(mockData);
-    expect(response!.fromCache).toBe(false);
-    expect(response!.etag).toBe('"abc123"');
-    expect(result.current.cacheSize).toBe(1);
-  });
-
-  it('fetchWithETag sends If-None-Match header on subsequent requests', async () => {
-    const mockData = { id: 1 };
-    const fetchSpy = vi.spyOn(globalThis, 'fetch');
-
-    // First request — returns data with ETag
-    fetchSpy.mockResolvedValueOnce(
-      new Response(JSON.stringify(mockData), {
-        status: 200,
-        headers: new Headers({ etag: '"etag-1"' }),
-      }),
-    );
-
-    const { result } = renderHook(() => useETagCache());
-
-    await act(async () => {
-      await result.current.fetchWithETag('/api/data');
-    });
-
-    // Second request — server returns 304
-    fetchSpy.mockResolvedValueOnce(
-      new Response(null, { status: 304 }),
-    );
-
-    let response: { data: unknown; fromCache: boolean; etag?: string } | undefined;
-    await act(async () => {
-      response = await result.current.fetchWithETag('/api/data');
-    });
-
-    // Verify If-None-Match was sent
-    const secondCallArgs = fetchSpy.mock.calls[1];
-    const headers = secondCallArgs[1]?.headers as Headers;
-    expect(headers.get('If-None-Match')).toBe('"etag-1"');
-    expect(response!.fromCache).toBe(true);
-    expect(response!.data).toEqual(mockData);
-  });
-
-  it('invalidate removes a specific cache entry', async () => {
-    const mockData = { id: 1 };
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      new Response(JSON.stringify(mockData), {
-        status: 200,
-        headers: new Headers({ etag: '"etag-x"' }),
-      }),
-    );
-
-    const { result } = renderHook(() => useETagCache());
-
-    await act(async () => {
-      await result.current.fetchWithETag('/api/item');
-    });
-    expect(result.current.cacheSize).toBe(1);
-
-    act(() => {
-      result.current.invalidate('/api/item');
-    });
-
-    expect(result.current.cacheSize).toBe(0);
-  });
-
-  it('clearCache removes all entries', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch');
-
-    fetchSpy.mockResolvedValueOnce(
-      new Response(JSON.stringify({ a: 1 }), {
-        status: 200,
-        headers: new Headers({ etag: '"e1"' }),
-      }),
-    );
-    fetchSpy.mockResolvedValueOnce(
-      new Response(JSON.stringify({ b: 2 }), {
-        status: 200,
-        headers: new Headers({ etag: '"e2"' }),
-      }),
-    );
-
-    const { result } = renderHook(() => useETagCache());
-
-    await act(async () => {
-      await result.current.fetchWithETag('/api/a');
-    });
-    await act(async () => {
-      await result.current.fetchWithETag('/api/b');
-    });
-
-    expect(result.current.cacheSize).toBe(2);
-
-    act(() => {
-      result.current.clearCache();
-    });
-
-    expect(result.current.cacheSize).toBe(0);
-  });
-
-  it('serviceWorkerActive is false initially', () => {
-    const { result } = renderHook(() => useETagCache());
-
-    expect(result.current.serviceWorkerActive).toBe(false);
-  });
-});

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

@@ -1,86 +0,0 @@
-/**
- * Tests for useExpression and useCondition hooks
- */
-
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useExpression, useCondition } from '../useExpression';
-
-describe('useExpression', () => {
-  it('returns string value directly for non-expression strings', () => {
-    const { result } = renderHook(() => useExpression('hello'));
-
-    expect(result.current).toBe('hello');
-  });
-
-  it('returns number value directly', () => {
-    const { result } = renderHook(() => useExpression(42));
-
-    expect(result.current).toBe(42);
-  });
-
-  it('returns boolean value directly', () => {
-    const { result } = renderHook(() => useExpression(true));
-
-    expect(result.current).toBe(true);
-  });
-
-  it('returns null for null expressions', () => {
-    const { result } = renderHook(() => useExpression(null));
-
-    expect(result.current).toBeNull();
-  });
-
-  it('returns undefined for undefined expressions', () => {
-    const { result } = renderHook(() => useExpression(undefined));
-
-    expect(result.current).toBeUndefined();
-  });
-
-  it('evaluates expressions with ${...} syntax', () => {
-    const context = { data: { name: 'John' } };
-    const { result } = renderHook(() =>
-      useExpression('${data.name}', context),
-    );
-
-    expect(result.current).toBe('John');
-  });
-
-  it('evaluates expressions with context data', () => {
-    const context = { data: { age: 25 } };
-    const { result } = renderHook(() =>
-      useExpression('${data.age > 18}', context),
-    );
-
-    expect(result.current).toBe(true);
-  });
-});
-
-describe('useCondition', () => {
-  it('returns true for boolean true', () => {
-    const { result } = renderHook(() => useCondition(true));
-
-    expect(result.current).toBe(true);
-  });
-
-  it('returns false for boolean false', () => {
-    const { result } = renderHook(() => useCondition(false));
-
-    expect(result.current).toBe(false);
-  });
-
-  it('returns true for undefined', () => {
-    const { result } = renderHook(() => useCondition(undefined));
-
-    expect(result.current).toBe(true);
-  });
-
-  it('evaluates string conditions with context', () => {
-    const context = { data: { status: 'active' } };
-    const { result } = renderHook(() =>
-      useCondition('${data.status === "active"}', context),
-    );
-
-    expect(result.current).toBe(true);
-  });
-});