@semiont/react-ui 0.4.19 → 0.4.21

package/src/features/resource-viewer/__tests__/AnnotationProgressDismissal.test.tsx

@@ -1,303 +0,0 @@
-/**
- * Bug Reproduction: Detection Progress Doesn't Dismiss
- *
- * USER SCENARIO:
- * 1. User clicks "Detect References" button
- * 2. Progress modal appears showing "Processing: Location"
- * 3. Detection completes successfully
- * 4. BUG: Progress modal stays visible showing "Processing: Location" indefinitely
- *
- * ROOT CAUSE:
- * - useMarkFlow.ts (line 54-62): mark:assist-finished clears `assistingMotivation` but keeps `progress`
- * - AssistSection.tsx (line 214): Shows progress UI whenever `progress` is not null
- * - No mechanism to auto-dismiss or manually close the progress display
- *
- * FIX OPTIONS:
- * A) Auto-dismiss after timeout (3s after completion)
- * B) Add "Close" button to progress display
- * C) Clear progress on next mark:assist-request (already works but not ideal UX)
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import { act } from 'react';
-import { useMarkFlow } from '../../../hooks/useMarkFlow';
-import { EventBusProvider, useEventBus } from '../../../contexts/EventBusContext';
-import { ApiClientProvider } from '../../../contexts/ApiClientContext';
-import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
-import { SemiontApiClient } from '@semiont/api-client';
-import { resourceId } from '@semiont/core';
-
-// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
-vi.mock('../../../components/Toast', () => ({
-  useToast: () => ({
-    showSuccess: vi.fn(),
-    showError: vi.fn(),
-    showInfo: vi.fn(),
-    showWarning: vi.fn(),
-  }),
-}));
-
-describe('Detection Progress Dismissal Bug', () => {
-  const rUri = resourceId('test');
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    vi.spyOn(SemiontApiClient.prototype, 'annotateReferences').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-    vi.spyOn(SemiontApiClient.prototype, 'annotateHighlights').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-    vi.spyOn(SemiontApiClient.prototype, 'annotateComments').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-    vi.spyOn(SemiontApiClient.prototype, 'annotateAssessments').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('FIXED: Progress auto-dismisses after detection completes', { timeout: 7000 }, async () => {
-    let eventBusInstance: any;
-
-    function TestHarness() {
-      eventBusInstance = useEventBus();
-      const { assistingMotivation, progress } = useMarkFlow(rUri);
-
-      return (
-        <div>
-          <div data-testid="detecting">{assistingMotivation || 'none'}</div>
-          <div data-testid="progress">
-            {progress ? progress.message || 'has progress' : 'no progress'}
-          </div>
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestHarness />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    // Initial state
-    expect(screen.getByTestId('detecting')).toHaveTextContent('none');
-    expect(screen.getByTestId('progress')).toHaveTextContent('no progress');
-
-    // User clicks detect button (emits mark:assist-request)
-    act(() => {
-      eventBusInstance.get('mark:assist-request').next({
-        motivation: 'linking',
-        options: { entityTypes: ['Location'] }
-      });
-    });
-
-    // Detection started
-    await waitFor(() => {
-      expect(screen.getByTestId('detecting')).toHaveTextContent('linking');
-    });
-
-    // SSE sends progress update
-    act(() => {
-      eventBusInstance.get('mark:progress').next({
-        status: 'scanning',
-        message: 'Processing: Location',
-        currentEntityType: 'Location',
-      });
-    });
-
-    // Progress is visible
-    await waitFor(() => {
-      expect(screen.getByTestId('progress')).toHaveTextContent('Processing: Location');
-    });
-
-    // Detection completes (SSE finishes, backend emits mark:assist-finished)
-    act(() => {
-      eventBusInstance.get('mark:assist-finished').next({ motivation: 'linking' });
-    });
-
-    // assistingMotivation cleared immediately
-    await waitFor(() => {
-      expect(screen.getByTestId('detecting')).toHaveTextContent('none');
-    });
-
-    // Wait 5 seconds - progress auto-dismissed after completion
-    await new Promise(resolve => setTimeout(resolve, 5100));
-    expect(screen.getByTestId('progress')).toHaveTextContent('no progress');
-  });
-
-  it('WORKAROUND: Starting new detection clears old progress', async () => {
-    let eventBusInstance: any;
-
-    function TestHarness() {
-      eventBusInstance = useEventBus();
-      const { progress } = useMarkFlow(rUri);
-
-      return (
-        <div data-testid="progress">
-          {progress ? progress.message || 'has progress' : 'no progress'}
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestHarness />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    // First detection with stuck progress
-    act(() => {
-      eventBusInstance.get('mark:assist-request').next({ motivation: 'linking', options: {} });
-    });
-
-    act(() => {
-      eventBusInstance.get('mark:progress').next({ message: 'Old progress stuck here' });
-    });
-
-    act(() => {
-      eventBusInstance.get('mark:assist-finished').next({ motivation: 'linking' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('progress')).toHaveTextContent('Old progress stuck here');
-    });
-
-    // WORKAROUND: Start new detection clears old progress
-    act(() => {
-      eventBusInstance.get('mark:assist-request').next({ motivation: 'highlighting', options: {} });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('progress')).toHaveTextContent('no progress');
-    });
-  });
-
-  it('NEW FEATURE: Progress should auto-dismiss after 5 seconds', { timeout: 7000 }, async () => {
-    // This test verifies the new auto-dismiss feature
-
-    let eventBusInstance: any;
-
-    function TestHarness() {
-      eventBusInstance = useEventBus();
-      const { progress } = useMarkFlow(rUri);
-
-      return (
-        <div data-testid="progress">
-          {progress ? 'visible' : 'dismissed'}
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestHarness />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    // Show progress
-    act(() => {
-      eventBusInstance.get('mark:assist-request').next({ motivation: 'linking', options: {} });
-    });
-
-    act(() => {
-      eventBusInstance.get('mark:progress').next({
-        status: 'complete',
-        message: 'Complete! Created 5 annotations'
-      });
-    });
-
-    act(() => {
-      eventBusInstance.get('mark:assist-finished').next({ motivation: 'linking' });
-    });
-
-    // Progress visible initially
-    await waitFor(() => {
-      expect(screen.getByTestId('progress')).toHaveTextContent('visible');
-    });
-
-    // Auto-dismiss after 5 seconds
-    await new Promise(resolve => setTimeout(resolve, 5100));
-
-    await waitFor(() => {
-      expect(screen.getByTestId('progress')).toHaveTextContent('dismissed');
-    });
-  });
-
-  it('FIXED: SSE emits final completion chunk data as annotate:assist-progress', async () => {
-    /**
-     * This test verifies that SSE emits the final chunk as annotate:assist-progress
-     * BEFORE emitting mark:assist-finished.
-     *
-     * This ensures the UI can display the final completion message with status:'complete'.
-     */
-
-    let eventBusInstance: any;
-
-    function TestHarness() {
-      eventBusInstance = useEventBus();
-      const { progress } = useMarkFlow(rUri);
-
-      return (
-        <div>
-          <div data-testid="progress-status">{progress?.status || 'none'}</div>
-          <div data-testid="progress-message">{progress?.message || 'no message'}</div>
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestHarness />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    // Start detection (triggers SSE stream creation)
-    act(() => {
-      eventBusInstance.get('mark:assist-request').next({
-        motivation: 'linking',
-        options: { entityTypes: ['Location'] }
-      });
-    });
-
-    // Simulate SSE scanning chunk
-    act(() => {
-      eventBusInstance.get('mark:progress').next({
-        status: 'scanning',
-        message: 'Processing: Location',
-      });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('progress-status')).toHaveTextContent('scanning');
-    });
-
-    // Simulate SSE emitting final chunk as annotate:assist-progress
-    act(() => {
-      eventBusInstance.get('mark:progress').next({
-        status: 'complete',
-        message: 'Complete! Found 5 entities',
-        foundCount: 5,
-      });
-    });
-
-    // Verify final chunk is now visible
-    await waitFor(() => {
-      expect(screen.getByTestId('progress-status')).toHaveTextContent('complete');
-      expect(screen.getByTestId('progress-message')).toHaveTextContent('Complete! Found 5 entities');
-    });
-  });
-});

package/src/features/resource-viewer/__tests__/BindFlowIntegration.test.tsx

@@ -1,150 +0,0 @@
-/**
- * Layer 3: Feature Integration Test - Bind Flow (body update)
- *
- * Tests the write side of useBindFlow:
- * - bind:update-body → calls http.bindAnnotation API (plain POST)
- * - bind:update-body → emits bind:body-update-failed on error
- * - auth token passed to bindAnnotation
- *
- * After the UNIFIED-STREAM migration, bind is a plain POST returning
- * {correlationId}. The state change arrives on the events-stream as
- * mark:body-updated. These tests focus on the POST call, not the
- * events-stream delivery (which is tested in AnnotationStore tests).
- *
- * Uses real providers (EventBus, ApiClient, AuthToken) with mocked API boundary.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, waitFor } from '@testing-library/react';
-import { act } from 'react';
-import { useBindFlow } from '../../../hooks/useBindFlow';
-import { EventBusProvider, useEventBus } from '../../../contexts/EventBusContext';
-import { ApiClientProvider } from '../../../contexts/ApiClientContext';
-import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
-import { SemiontApiClient } from '@semiont/api-client';
-import { resourceId, annotationId } from '@semiont/core';
-
-const mockShowError = vi.fn();
-
-vi.mock('../../../components/Toast', () => ({
-  useToast: () => ({
-    showSuccess: vi.fn(),
-    showError: mockShowError,
-    showInfo: vi.fn(),
-    showWarning: vi.fn(),
-  }),
-}));
-
-describe('Bind Flow - Body Update Integration', () => {
-  let bindAnnotationSpy: ReturnType<typeof vi.fn>;
-  const testId = resourceId('test-resource');
-  const testToken = 'test-resolution-token';
-  const testBaseUrl = 'http://localhost:4000';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Mock the HTTP bindAnnotation method (plain POST, returns {correlationId})
-    bindAnnotationSpy = vi.fn().mockResolvedValue({ correlationId: 'corr-test' });
-    vi.spyOn(SemiontApiClient.prototype, 'bindAnnotation').mockImplementation(bindAnnotationSpy as any);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  // ─── Render helper ──────────────────────────────────────────────────────────
-
-  function renderBindFlow() {
-    let eventBusInstance: ReturnType<typeof useEventBus> | null = null;
-
-    function TestComponent() {
-      eventBusInstance = useEventBus();
-      useBindFlow(testId);
-      return null;
-    }
-
-    render(
-      <AuthTokenProvider token={testToken}>
-        <EventBusProvider>
-          <ApiClientProvider baseUrl={testBaseUrl}>
-            <TestComponent />
-          </ApiClientProvider>
-        </EventBusProvider>
-      </AuthTokenProvider>
-    );
-
-    return {
-      getEventBus: () => eventBusInstance!,
-    };
-  }
-
-  // ─── bind:update-body ──────────────────────────────────────────────────
-
-  it('bind:update-body calls http.bindAnnotation (plain POST)', async () => {
-    const { getEventBus } = renderBindFlow();
-
-    act(() => { getEventBus().get('bind:update-body').next({
-      correlationId: 'corr-1',
-      annotationId: annotationId('ann-body-1'),
-      resourceId: resourceId('linked-resource-id'),
-      operations: [{ op: 'add', item: { type: 'SpecificResource' as const, source: 'linked-resource-id' } }],
-    }); });
-
-    await waitFor(() => {
-      expect(bindAnnotationSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it('bind:update-body passes auth token to API call', async () => {
-    const { getEventBus } = renderBindFlow();
-
-    act(() => { getEventBus().get('bind:update-body').next({
-      correlationId: 'corr-2',
-      annotationId: annotationId('ann-auth'),
-      resourceId: resourceId('resource-id'),
-      operations: [{ op: 'replace', newItem: { type: 'SpecificResource' as const, source: 'resource-id' } }],
-    }); });
-
-    await waitFor(() => {
-      expect(bindAnnotationSpy).toHaveBeenCalled();
-    });
-
-    const callArgs = bindAnnotationSpy.mock.calls[0];
-    expect(callArgs[3]).toHaveProperty('auth');
-  });
-
-  it('bind:update-body shows error toast on API error', async () => {
-    bindAnnotationSpy.mockRejectedValueOnce(new Error('Update failed'));
-
-    const { getEventBus } = renderBindFlow();
-
-    act(() => { getEventBus().get('bind:update-body').next({
-      correlationId: 'corr-3',
-      annotationId: annotationId('ann-fail'),
-      resourceId: resourceId('resource-id'),
-      operations: [{ op: 'remove', item: { type: 'SpecificResource' as const, source: 'old-id' } }],
-    }); });
-
-    await waitFor(() => {
-      expect(mockShowError).toHaveBeenCalledWith(
-        expect.stringContaining('Update failed'),
-      );
-    });
-  });
-
-  it('bind:update-body called ONCE — no duplicate subscriptions', async () => {
-    const { getEventBus } = renderBindFlow();
-
-    act(() => { getEventBus().get('bind:update-body').next({
-      correlationId: 'corr-4',
-      annotationId: annotationId('ann-dedup'),
-      resourceId: resourceId('resource-id'),
-      operations: [{ op: 'add', item: { type: 'SpecificResource' as const, source: 'resource-id' } }],
-    }); });
-
-    await waitFor(() => {
-      expect(bindAnnotationSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/src/features/resource-viewer/__tests__/DetectionFlowBug.test.tsx

@@ -1,243 +0,0 @@
-/**
- * FAILING TEST: Reproduces the bug where detection events fire but state doesn't update
- *
- * Based on console logs from production:
- * ✅ mark:assist-request emitted
- * ✅ annotate:assist-progress emitted
- * ❌ assistingMotivation remains null
- * ❌ progress remains null
- *
- * UPDATED: Now tests useMarkFlow hook instead of DetectionFlowContainer
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import { act } from 'react';
-import { useMarkFlow } from '../../../hooks/useMarkFlow';
-import { EventBusProvider, useEventBus } from '../../../contexts/EventBusContext';
-import { ApiClientProvider } from '../../../contexts/ApiClientContext';
-import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
-import { SemiontApiClient } from '@semiont/api-client';
-
-// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
-vi.mock('../../../components/Toast', () => ({
-  useToast: () => ({
-    showSuccess: vi.fn(),
-    showError: vi.fn(),
-    showInfo: vi.fn(),
-    showWarning: vi.fn(),
-  }),
-}));
-
-describe('REPRODUCING BUG: Detection state not updating', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Minimal mock — namespace methods call these HTTP methods internally
-    vi.spyOn(SemiontApiClient.prototype, 'annotateReferences').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-    vi.spyOn(SemiontApiClient.prototype, 'annotateHighlights').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-    vi.spyOn(SemiontApiClient.prototype, 'annotateComments').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-    vi.spyOn(SemiontApiClient.prototype, 'annotateAssessments').mockResolvedValue({ correlationId: 'c1', jobId: 'j1' });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('SHOULD update state when mark:assist-request event is emitted', async () => {
-    let eventBusInstance: any;
-    let currentState: any;
-
-    // Component to capture EventBus and hook state
-    function TestComponent() {
-      eventBusInstance = useEventBus();
-      const state = useMarkFlow('test' as any);
-      currentState = state;
-
-      console.log('[TEST] useMarkFlow state:', {
-        assistingMotivation: state.assistingMotivation,
-        progress: state.progress,
-      });
-
-      return (
-        <div>
-          <div data-testid="detecting">{state.assistingMotivation || 'null'}</div>
-          <div data-testid="progress">{state.progress?.message || 'null'}</div>
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestComponent />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    // Initial state should be null
-    expect(screen.getByTestId('detecting')).toHaveTextContent('null');
-    expect(screen.getByTestId('progress')).toHaveTextContent('null');
-
-    console.log('[TEST] Emitting mark:assist-request event...');
-
-    // Emit mark:assist-request event (exactly like production)
-    act(() => {
-      eventBusInstance.get('mark:assist-request').next({
-        motivation: 'linking',
-        options: { entityTypes: ['Location'] }
-      });
-    });
-
-    console.log('[TEST] After mark:assist-request, checking state...');
-
-    // THIS SHOULD PASS but currently FAILS
-    await waitFor(() => {
-      expect(screen.getByTestId('detecting')).toHaveTextContent('linking');
-    }, { timeout: 1000 });
-
-    expect(currentState.assistingMotivation).toBe('linking');
-    expect(currentState.progress).toBeNull(); // Should clear on start
-  });
-
-  it('SHOULD update state when annotate:assist-progress event is emitted', async () => {
-    let eventBusInstance: any;
-    let currentState: any;
-
-    function TestComponent() {
-      eventBusInstance = useEventBus();
-      const state = useMarkFlow('test' as any);
-      currentState = state;
-
-      return (
-        <div>
-          <div data-testid="detecting">{state.assistingMotivation || 'null'}</div>
-          <div data-testid="progress">{state.progress?.message || 'null'}</div>
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestComponent />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    console.log('[TEST] Emitting annotate:assist-progress event...');
-
-    // Emit annotate:assist-progress event (exactly like production)
-    act(() => {
-      eventBusInstance.get('mark:progress').next({
-        status: 'started',
-        resourceId: 'test',
-        totalEntityTypes: 1,
-        processedEntityTypes: 0,
-        message: 'Starting entity detection...'
-      });
-    });
-
-    console.log('[TEST] After annotate:assist-progress, checking state...');
-
-    // THIS SHOULD PASS but currently FAILS
-    await waitFor(() => {
-      expect(screen.getByTestId('progress')).toHaveTextContent('Starting entity detection...');
-    }, { timeout: 1000 });
-
-    expect(currentState.progress).toMatchObject({
-      status: 'started',
-      message: 'Starting entity detection...'
-    });
-  });
-
-  it('SHOULD show EXACTLY the production bug', async () => {
-    let eventBusInstance: any;
-    const stateSnapshots: any[] = [];
-
-    function TestComponent() {
-      eventBusInstance = useEventBus();
-      const state = useMarkFlow('f45fd44f9cb0b0fe1b7980d3d034bc61' as any);
-
-      stateSnapshots.push({
-        assistingMotivation: state.assistingMotivation,
-        progress: state.progress,
-      });
-
-      return (
-        <div>
-          <div data-testid="detecting">{state.assistingMotivation || 'null'}</div>
-          <div data-testid="progress">{state.progress?.message || 'null'}</div>
-        </div>
-      );
-    }
-
-    render(
-      <EventBusProvider>
-        <AuthTokenProvider token={null}>
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <TestComponent />
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
-    );
-
-    console.log('\n=== REPRODUCING PRODUCTION BUG ===');
-    console.log('Initial state:', stateSnapshots[stateSnapshots.length - 1]);
-
-    // Exactly like production logs
-    act(() => {
-      console.log('[EventBus] emit: mark:assist-request {motivation: "linking", options: {...}}');
-      eventBusInstance.get('mark:assist-request').next({
-        motivation: 'linking',
-        options: { entityTypes: ['Location'] }
-      });
-    });
-
-    console.log('After mark:assist-request:', stateSnapshots[stateSnapshots.length - 1]);
-
-    act(() => {
-      console.log('[EventBus] emit: annotate:assist-progress {status: "started", ...}');
-      eventBusInstance.get('mark:progress').next({
-        status: 'started',
-        resourceId: 'f45fd44f9cb0b0fe1b7980d3d034bc61',
-        totalEntityTypes: 1,
-        processedEntityTypes: 0,
-        message: 'Starting entity detection...'
-      });
-    });
-
-    console.log('After annotate:assist-progress:', stateSnapshots[stateSnapshots.length - 1]);
-
-    act(() => {
-      console.log('[EventBus] emit: annotate:assist-progress {status: "scanning", ...}');
-      eventBusInstance.get('mark:progress').next({
-        status: 'scanning',
-        resourceId: 'f45fd44f9cb0b0fe1b7980d3d034bc61',
-        currentEntityType: 'Location',
-        totalEntityTypes: 1,
-        processedEntityTypes: 1,
-        message: 'Scanning for Location...'
-      });
-    });
-
-    console.log('After second annotate:assist-progress:', stateSnapshots[stateSnapshots.length - 1]);
-    console.log('=== END REPRODUCTION ===\n');
-
-    // THIS IS THE BUG: Events fire but state never updates
-    // Production logs show: assistingMotivation: null, progress: null
-    // Even though events were emitted
-    await waitFor(() => {
-      const currentSnapshot = stateSnapshots[stateSnapshots.length - 1];
-      console.log('Final state check:', currentSnapshot);
-
-      // These SHOULD pass but will FAIL if bug is present
-      expect(currentSnapshot.assistingMotivation).toBe('linking');
-      expect(currentSnapshot.progress?.message).toBe('Scanning for Location...');
-    }, { timeout: 2000 });
-  });
-});