@object-ui/react 3.3.0 → 3.3.1

package/src/__tests__/LazyPluginLoader.test.tsx

@@ -1,176 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import React from 'react';
-import { createLazyPlugin, preloadPlugin } from '../LazyPluginLoader';
-
-describe('createLazyPlugin', () => {
-  it('should create a lazy-loaded component', async () => {
-    const TestComponent = () => <div>Test Component</div>;
-    
-    const LazyComponent = createLazyPlugin(
-      () => Promise.resolve({ default: TestComponent })
-    );
-    
-    render(<LazyComponent />);
-    
-    await waitFor(() => {
-      expect(screen.getByText('Test Component')).toBeInTheDocument();
-    });
-  });
-
-  it('should show custom fallback while loading', async () => {
-    const TestComponent = () => <div>Test Component</div>;
-    
-    const LazyComponent = createLazyPlugin(
-      () => new Promise<{ default: React.ComponentType }>((resolve) => {
-        setTimeout(() => resolve({ default: TestComponent }), 100);
-      }),
-      { fallback: <div>Loading...</div> }
-    );
-    
-    render(<LazyComponent />);
-    
-    expect(screen.getByText('Loading...')).toBeInTheDocument();
-    
-    await waitFor(() => {
-      expect(screen.getByText('Test Component')).toBeInTheDocument();
-    });
-  });
-
-  it('should pass props to the lazy component', async () => {
-    interface TestProps {
-      message: string;
-    }
-    
-    const TestComponent = ({ message }: TestProps) => <div>{message}</div>;
-    
-    const LazyComponent = createLazyPlugin<TestProps>(
-      () => Promise.resolve({ default: TestComponent })
-    );
-    
-    render(<LazyComponent message="Hello World" />);
-    
-    await waitFor(() => {
-      expect(screen.getByText('Hello World')).toBeInTheDocument();
-    });
-  });
-
-  it('should handle loading errors gracefully', async () => {
-    // Mock console.error to avoid noise in test output
-    const originalError = console.error;
-    console.error = vi.fn();
-
-    const LazyComponent = createLazyPlugin<any>(
-      () => Promise.reject(new Error('Load error'))
-    );
-    
-    expect(() => render(<LazyComponent />)).not.toThrow();
-    
-    // Restore console.error
-    console.error = originalError;
-  });
-
-  it('should preload a plugin without rendering', async () => {
-    const TestComponent = () => <div>Preloaded</div>;
-    const importFn = vi.fn(() => Promise.resolve({ default: TestComponent }));
-
-    const result = await preloadPlugin(importFn);
-
-    expect(importFn).toHaveBeenCalledTimes(1);
-    expect(result).toEqual({ default: TestComponent });
-  });
-
-  it('should render errorFallback when component fails to load', async () => {
-    const originalError = console.error;
-    console.error = vi.fn();
-
-    const ErrorFallback = ({ error, retry }: { error: Error; retry: () => void }) => (
-      <div>
-        <span>Error: {error.message}</span>
-        <button onClick={retry}>Retry</button>
-      </div>
-    );
-
-    const LazyComponent = createLazyPlugin(
-      () => Promise.reject(new Error('chunk failed')),
-      { retries: 0, errorFallback: ErrorFallback }
-    );
-
-    render(<LazyComponent />);
-
-    await waitFor(() => {
-      expect(screen.getByText('Error: chunk failed')).toBeInTheDocument();
-    });
-
-    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument();
-
-    console.error = originalError;
-  });
-
-  it('should not retry when retries=0', async () => {
-    const originalError = console.error;
-    console.error = vi.fn();
-
-    const importFn = vi.fn(() => Promise.reject(new Error('fail')));
-
-    const ErrorFallback = ({ error }: { error: Error; retry: () => void }) => (
-      <div>Error: {error.message}</div>
-    );
-
-    const LazyComponent = createLazyPlugin(importFn, {
-      retries: 0,
-      errorFallback: ErrorFallback,
-    });
-
-    render(<LazyComponent />);
-
-    await waitFor(() => {
-      expect(screen.getByText('Error: fail')).toBeInTheDocument();
-    });
-
-    // Called only once — no retries
-    expect(importFn).toHaveBeenCalledTimes(1);
-
-    console.error = originalError;
-  });
-
-  it('should retry on failure then succeed', async () => {
-    const originalError = console.error;
-    console.error = vi.fn();
-
-    const TestComponent = () => <div>Success after retry</div>;
-
-    let callCount = 0;
-    const importFn = vi.fn(() => {
-      callCount++;
-      if (callCount <= 2) {
-        return Promise.reject(new Error('transient error'));
-      }
-      return Promise.resolve({ default: TestComponent as React.ComponentType });
-    });
-
-    const LazyComponent = createLazyPlugin(importFn, {
-      retries: 3,
-      retryDelay: 10,
-    });
-
-    render(<LazyComponent />);
-
-    await waitFor(() => {
-      expect(screen.getByText('Success after retry')).toBeInTheDocument();
-    }, { timeout: 2000 });
-
-    // First call + 2 retries (fails) + 1 success = called 3 times
-    expect(importFn).toHaveBeenCalledTimes(3);
-
-    console.error = originalError;
-  });
-});

package/src/__tests__/SchemaRenderer.aria.test.tsx

@@ -1,118 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer } from '../SchemaRenderer';
-
-// A simple test component that forwards ARIA attributes
-const TestWidget: React.FC<any> = (props) => (
-  <div
-    data-testid="test-widget"
-    aria-label={props['aria-label']}
-    aria-describedby={props['aria-describedby']}
-    role={props['role']}
-  >
-    {props.content || 'Test'}
-  </div>
-);
-
-describe('SchemaRenderer AriaProps injection', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('test-widget', TestWidget);
-  });
-
-  afterEach(() => {
-    ComponentRegistry.unregister?.('test-widget');
-  });
-
-  it('should inject aria-label from ariaLabel string', () => {
-    render(
-      <SchemaRenderer
-        schema={{
-          type: 'test-widget',
-          ariaLabel: 'Close dialog',
-        }}
-      />
-    );
-    const el = screen.getByTestId('test-widget');
-    expect(el).toHaveAttribute('aria-label', 'Close dialog');
-  });
-
-  it('should resolve ariaLabel from I18nLabel object', () => {
-    render(
-      <SchemaRenderer
-        schema={{
-          type: 'test-widget',
-          ariaLabel: { key: 'dialog.close', defaultValue: 'Close dialog' },
-        }}
-      />
-    );
-    const el = screen.getByTestId('test-widget');
-    expect(el).toHaveAttribute('aria-label', 'Close dialog');
-  });
-
-  it('should inject aria-describedby from ariaDescribedBy', () => {
-    render(
-      <SchemaRenderer
-        schema={{
-          type: 'test-widget',
-          ariaDescribedBy: 'help-text-1',
-        }}
-      />
-    );
-    const el = screen.getByTestId('test-widget');
-    expect(el).toHaveAttribute('aria-describedby', 'help-text-1');
-  });
-
-  it('should inject role from schema', () => {
-    render(
-      <SchemaRenderer
-        schema={{
-          type: 'test-widget',
-          role: 'navigation',
-        }}
-      />
-    );
-    const el = screen.getByTestId('test-widget');
-    expect(el).toHaveAttribute('role', 'navigation');
-  });
-
-  it('should inject all ARIA props together', () => {
-    render(
-      <SchemaRenderer
-        schema={{
-          type: 'test-widget',
-          ariaLabel: 'Main nav',
-          ariaDescribedBy: 'nav-desc',
-          role: 'navigation',
-        }}
-      />
-    );
-    const el = screen.getByTestId('test-widget');
-    expect(el).toHaveAttribute('aria-label', 'Main nav');
-    expect(el).toHaveAttribute('aria-describedby', 'nav-desc');
-    expect(el).toHaveAttribute('role', 'navigation');
-  });
-
-  it('should not inject ARIA attrs when not in schema', () => {
-    render(
-      <SchemaRenderer
-        schema={{
-          type: 'test-widget',
-          content: 'Hello',
-        }}
-      />
-    );
-    const el = screen.getByTestId('test-widget');
-    expect(el).not.toHaveAttribute('aria-label');
-    expect(el).not.toHaveAttribute('aria-describedby');
-  });
-});

package/src/__tests__/SchemaRenderer.debug.test.tsx

@@ -1,69 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer } from '../SchemaRenderer';
-import { SchemaRendererProvider } from '../context/SchemaRendererContext';
-
-// Suppress console.warn from deprecated namespace registration
-const originalWarn = console.warn;
-beforeEach(() => {
-  console.warn = vi.fn();
-});
-afterEach(() => {
-  console.warn = originalWarn;
-});
-
-// A simple test component that passes all props through to a div
-const TestDiv: React.FC<any> = (props) => {
-  const { schema, ...rest } = props;
-  return <div data-testid="test-div" {...rest} />;
-};
-
-describe('SchemaRenderer debug attributes', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('test-debug-div', TestDiv);
-  });
-
-  it('should NOT inject data-debug-* attributes when debug is off', () => {
-    const { getByTestId } = render(
-      <SchemaRendererProvider dataSource={{}}>
-        <SchemaRenderer schema={{ type: 'test-debug-div', id: 'myBtn' }} />
-      </SchemaRendererProvider>,
-    );
-    const el = getByTestId('test-div');
-    expect(el.getAttribute('data-debug-type')).toBeNull();
-    expect(el.getAttribute('data-debug-id')).toBeNull();
-  });
-
-  it('should inject data-debug-type when debug is enabled', () => {
-    const { getByTestId } = render(
-      <SchemaRendererProvider dataSource={{}} debug={true}>
-        <SchemaRenderer schema={{ type: 'test-debug-div', id: 'myBtn' }} />
-      </SchemaRendererProvider>,
-    );
-    const el = getByTestId('test-div');
-    expect(el.getAttribute('data-debug-type')).toBe('test-debug-div');
-    expect(el.getAttribute('data-debug-id')).toBe('myBtn');
-  });
-
-  it('should inject data-debug-type when debugFlags.enabled is true', () => {
-    const { getByTestId } = render(
-      <SchemaRendererProvider dataSource={{}} debugFlags={{ enabled: true }}>
-        <SchemaRenderer schema={{ type: 'test-debug-div' }} />
-      </SchemaRendererProvider>,
-    );
-    const el = getByTestId('test-div');
-    expect(el.getAttribute('data-debug-type')).toBe('test-debug-div');
-    // No id on schema, so data-debug-id should not be present
-    expect(el.getAttribute('data-debug-id')).toBeNull();
-  });
-});

package/src/__tests__/SchemaRenderer.errorBoundary.test.tsx

@@ -1,114 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { render, screen, fireEvent } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer, SchemaErrorBoundary } from '../SchemaRenderer';
-
-// Suppress console.error from React error boundary during tests
-const originalConsoleError = console.error;
-beforeEach(() => {
-  console.error = vi.fn();
-});
-afterEach(() => {
-  console.error = originalConsoleError;
-});
-
-const CrashingWidget: React.FC = () => {
-  throw new Error('Widget exploded!');
-};
-
-const StableWidget: React.FC<any> = (props) => (
-  <div data-testid="stable-widget">{props.content || 'Stable'}</div>
-);
-
-describe('SchemaErrorBoundary', () => {
-  it('should render children normally when no error', () => {
-    render(
-      <SchemaErrorBoundary>
-        <div data-testid="child">OK</div>
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByTestId('child')).toBeInTheDocument();
-  });
-
-  it('should catch render errors and display fallback', () => {
-    render(
-      <SchemaErrorBoundary componentType="crashing-widget">
-        <CrashingWidget />
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByText(/failed to render/i)).toBeInTheDocument();
-    expect(screen.getByText(/"crashing-widget"/)).toBeInTheDocument();
-    expect(screen.getByText('Widget exploded!')).toBeInTheDocument();
-  });
-
-  it('should display retry button that resets the error', () => {
-    render(
-      <SchemaErrorBoundary>
-        <CrashingWidget />
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    const retryButton = screen.getByText('Retry');
-    expect(retryButton).toBeInTheDocument();
-  });
-
-  it('should work without componentType prop', () => {
-    render(
-      <SchemaErrorBoundary>
-        <CrashingWidget />
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByText(/failed to render/i)).toBeInTheDocument();
-  });
-});
-
-describe('SchemaRenderer error boundary integration', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('crashing-widget', CrashingWidget);
-    ComponentRegistry.register('stable-widget', StableWidget);
-  });
-
-  afterEach(() => {
-    ComponentRegistry.unregister?.('crashing-widget');
-    ComponentRegistry.unregister?.('stable-widget');
-  });
-
-  it('should catch errors from a crashing component', () => {
-    render(
-      <SchemaRenderer schema={{ type: 'crashing-widget' }} />
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByText('Widget exploded!')).toBeInTheDocument();
-  });
-
-  it('should not affect stable components', () => {
-    render(
-      <SchemaRenderer schema={{ type: 'stable-widget', content: 'Hello' }} />
-    );
-    expect(screen.getByTestId('stable-widget')).toBeInTheDocument();
-    expect(screen.getByText('Hello')).toBeInTheDocument();
-  });
-
-  it('should isolate crashes between multiple renderers', () => {
-    render(
-      <div>
-        <SchemaRenderer schema={{ type: 'crashing-widget' }} />
-        <SchemaRenderer schema={{ type: 'stable-widget', content: 'Still works' }} />
-      </div>
-    );
-    // Crashing one should not affect the other
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByTestId('stable-widget')).toBeInTheDocument();
-    expect(screen.getByText('Still works')).toBeInTheDocument();
-  });
-});

package/src/__tests__/SchemaRenderer.expressions.test.tsx

@@ -1,131 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer } from '../SchemaRenderer';
-import { SchemaRendererContext } from '../context/SchemaRendererContext';
-
-// Simple test component
-const TestComponent = (props: any) => (
-  <div data-testid="test-component" data-disabled={props.disabled || undefined}>
-    {props.content || props.label || 'Test'}
-  </div>
-);
-
-describe('SchemaRenderer Expression Integration', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('test-component', TestComponent);
-  });
-
-  afterEach(() => {
-    ComponentRegistry.unregister?.('test-component');
-  });
-
-  describe('visible / hidden expressions', () => {
-    it('renders when visible is true', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', visible: true }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('does not render when visible is false', () => {
-      const { container } = render(<SchemaRenderer schema={{ type: 'test-component', visible: false }} />);
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('evaluates visible expression string', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { role: 'admin' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', visible: '${data.role === "admin"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('hides when visible expression evaluates to false', () => {
-      const { container } = render(
-        <SchemaRendererContext.Provider value={{ dataSource: { role: 'viewer' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', visible: '${data.role === "admin"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('hides when hidden is true', () => {
-      const { container } = render(<SchemaRenderer schema={{ type: 'test-component', hidden: true }} />);
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('shows when hidden is false', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', hidden: false }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('hides with hiddenOn expression', () => {
-      const { container } = render(
-        <SchemaRendererContext.Provider value={{ dataSource: { status: 'draft' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', hiddenOn: '${data.status === "draft"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('visible takes precedence over hidden', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', visible: true, hidden: true }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('disabled expressions', () => {
-    it('passes disabled=true when disabled expression is true', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', disabled: true }} />);
-      expect(screen.getByTestId('test-component')).toHaveAttribute('data-disabled', 'true');
-    });
-
-    it('evaluates disabled expression string', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { status: 'locked' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', disabled: '${data.status === "locked"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).toHaveAttribute('data-disabled', 'true');
-    });
-
-    it('does not set disabled when expression is false', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { status: 'active' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', disabled: '${data.status === "locked"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).not.toHaveAttribute('data-disabled');
-    });
-
-    it('evaluates disabledOn expression', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { readOnly: true } }}>
-          <SchemaRenderer schema={{ type: 'test-component', disabledOn: '${data.readOnly}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).toHaveAttribute('data-disabled', 'true');
-    });
-  });
-
-  describe('defaults', () => {
-    it('renders by default when no visibility props are set', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component' }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('is not disabled by default', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component' }} />);
-      expect(screen.getByTestId('test-component')).not.toHaveAttribute('data-disabled');
-    });
-  });
-});