@oanda/labs-crowd-view-widget 1.0.45 → 1.0.47

package/test/components/Chart/utils/chartUtils.test.ts

@@ -10,7 +10,11 @@ import {
   BOOKS_THRESHOLDS,
   COLOR_MAP,
 } from '../../../../src/CrowdViewWidget/constants';
-import { Granularity, TimeSpan } from '../../../../src/gql/types/graphql';
+import {
+  BookType,
+  Granularity,
+  TimeSpan,
+} from '../../../../src/gql/types/graphql';
 
 describe('chartUtils', () => {
   describe('getTimeSpanForGranularity', () => {
@@ -131,13 +135,15 @@ describe('chartUtils', () => {
         ],
       ];
 
-      const html = getTooltipFormatter(
+      const html = getTooltipFormatter({
         params,
         buckets,
-        0.0005,
-        1.3306,
-        labelCallback
-      );
+        bucketWidth: 0.0005,
+        selectedPrice: 1.3306,
+        precision: 5,
+        bookType: BookType.Order,
+        labelCallback,
+      });
       expect(html).toContain('candle');
       expect(html).toContain('open_price');
       expect(html).toContain('close_price');
@@ -146,27 +152,7 @@ describe('chartUtils', () => {
       expect(html).toContain('orders');
       expect(html).toContain('price_range');
       // Selected price 1.3306 falls into second bucket 1.3305 - 1.3310 which has negative sentiment
-      expect(html).toContain('sell_advantage');
-    });
-
-    it('omits sections when data is missing', () => {
-      const params = [
-        {
-          axisValue: '2025-03-15T10:30:00Z',
-          value: [0, 0, 0, 0, 0], // no candle values
-        },
-        { value: ['2025-03-15T10:30:00Z', 0, 0] },
-      ];
-      const buckets: Array<Array<{ price: number; sentiment: number }>> = [[]];
-      const html = getTooltipFormatter(
-        params,
-        buckets,
-        0.0005,
-        0,
-        labelCallback
-      );
-      expect(html).not.toContain('open_price');
-      expect(html).not.toContain('orders');
+      expect(html).toContain('sell_overbalance');
     });
   });
 });

package/test/components/Legend.test.tsx

@@ -6,17 +6,22 @@ import { render } from '@testing-library/react';
 import React from 'react';
 
 import { Legend } from '../../src/CrowdViewWidget/components';
+import { BookType } from '../../src/gql/types/graphql';
 
 describe('Crowd View Widget', () => {
   describe('components', () => {
     describe('<Legend />', () => {
       it('renders two LegendBar components', () => {
         const { getAllByText } = render(
-          <Legend longValues={[0.15, 0.55]} shortValues={[0.15, 0.55]} />
+          <Legend
+            bookType={BookType.Position}
+            longValues={[0.15, 0.55]}
+            shortValues={[0.15, 0.55]}
+          />
         );
 
-        expect(getAllByText(/long/)).toHaveLength(2);
-        expect(getAllByText(/short/)).toHaveLength(2);
+        expect(getAllByText(/long/)).toHaveLength(1);
+        expect(getAllByText(/short/)).toHaveLength(1);
       });
     });
   });

package/test/components/LegendBar.test.tsx

@@ -17,8 +17,9 @@ describe('Crowd View Widget', () => {
           <LegendBar label="long" type="long" values={mockValues} />
         );
 
-        expect(getByText('0.15% long')).toBeInTheDocument();
-        expect(getByText('0.55% long')).toBeInTheDocument();
+        expect(getByText('long')).toBeInTheDocument();
+        expect(getByText('0.15%')).toBeInTheDocument();
+        expect(getByText('≤ 0.55%')).toBeInTheDocument();
       });
 
       it('renders exactly 1 segment', () => {

package/test/utils/aggregateBuckets.test.ts

@@ -0,0 +1,82 @@
+import { aggregateBuckets } from '../../src/CrowdViewWidget/components';
+
+describe('aggregateBuckets', () => {
+  it('should correctly aggregate a standard set of buckets', () => {
+    const buckets = [
+      { price: 1, sentiment: 1 },
+      { price: 1.05, sentiment: 2 },
+      { price: 1.1, sentiment: 4 },
+      { price: 1.15, sentiment: 3 },
+      { price: 1.2, sentiment: 7 },
+      { price: 1.35, sentiment: 8 },
+      { price: 1.6, sentiment: 10 },
+      { price: 1.65, sentiment: 1 },
+      { price: 1.8, sentiment: 18 },
+    ];
+    const newBucketWidth = 0.1;
+    const expected = [
+      { price: 1.0, sentiment: 3 },
+      { price: 1.1, sentiment: 7 },
+      { price: 1.2, sentiment: 7 },
+      { price: 1.3, sentiment: 8 },
+      { price: 1.6, sentiment: 11 },
+      { price: 1.8, sentiment: 18 },
+    ];
+
+    expect(aggregateBuckets(buckets, newBucketWidth)).toEqual(expected);
+  });
+
+  it('should return an empty array if the input array is empty', () => {
+    expect(aggregateBuckets([], 0.1)).toEqual([]);
+  });
+
+  it('should correctly process an array with a single bucket', () => {
+    const buckets = [{ price: 2.58, sentiment: 15 }];
+    const newBucketWidth = 0.2;
+    const expected = [{ price: 2.4, sentiment: 15 }];
+
+    expect(aggregateBuckets(buckets, newBucketWidth)).toEqual(expected);
+  });
+
+  it('should handle gaps in data without creating empty buckets', () => {
+    const buckets = [
+      { price: 10.1, sentiment: 5 }, // Belongs to bucket 10.0
+      { price: 10.9, sentiment: 8 }, // Belongs to bucket 10.8
+    ];
+    const newBucketWidth = 0.2;
+    const expected = [
+      { price: 10.0, sentiment: 5 },
+      { price: 10.8, sentiment: 8 },
+    ];
+
+    expect(aggregateBuckets(buckets, newBucketWidth)).toEqual(expected);
+  });
+
+  it('should aggregate all items into a single bucket if they fall within the new width', () => {
+    const buckets = [
+      { price: 1.1, sentiment: 10 },
+      { price: 1.5, sentiment: 20 },
+      { price: 1.9, sentiment: 30 },
+    ];
+    const newBucketWidth = 2.0;
+    const expected = [{ price: 0.0, sentiment: 60 }];
+
+    expect(aggregateBuckets(buckets, newBucketWidth)).toEqual(expected);
+  });
+
+  it('should correctly sum sentiments including zero and negative values', () => {
+    const buckets = [
+      { price: 5.0, sentiment: 100 },
+      { price: 5.05, sentiment: -20 },
+      { price: 5.11, sentiment: 0 },
+      { price: 5.18, sentiment: 5 },
+    ];
+    const newBucketWidth = 0.1;
+    const expected = [
+      { price: 5.0, sentiment: 80 },
+      { price: 5.1, sentiment: 5 },
+    ];
+
+    expect(aggregateBuckets(buckets, newBucketWidth)).toEqual(expected);
+  });
+});

package/test/utils/getTargetBucketWidth.test.ts

@@ -0,0 +1,37 @@
+import { getTargetBucketWidth } from '../../src/CrowdViewWidget/components';
+import {
+  BUCKET_CONFIG,
+  INSTRUMENTS_CONFIG,
+} from '../../src/CrowdViewWidget/constants';
+import { InstrumentId } from '../../src/CrowdViewWidget/types';
+import { Granularity } from '../../src/gql/types/graphql';
+
+describe('getTargetBucketWidth', () => {
+  const instrument = InstrumentId.EUR_AUD;
+  const { defaultBucketWidth } = INSTRUMENTS_CONFIG[instrument];
+  const optimizedBucketWidth = defaultBucketWidth * BUCKET_CONFIG.MULTIPLIER;
+
+  it('should return optimized width for H1 granularity', () => {
+    expect(getTargetBucketWidth(Granularity.H1, instrument)).toBe(
+      optimizedBucketWidth
+    );
+  });
+
+  it('should return optimized width for H4 granularity', () => {
+    expect(getTargetBucketWidth(Granularity.H4, instrument)).toBe(
+      optimizedBucketWidth
+    );
+  });
+
+  it('should return default width for M5 granularity', () => {
+    expect(getTargetBucketWidth(Granularity.M5, instrument)).toBe(
+      defaultBucketWidth
+    );
+  });
+
+  it('should return default width for M15 granularity', () => {
+    expect(getTargetBucketWidth(Granularity.M15, instrument)).toBe(
+      defaultBucketWidth
+    );
+  });
+});

package/test/utils/instrumentUtils.test.ts

@@ -14,11 +14,13 @@ describe('instrumentUtils', () => {
       expect(Array.isArray(result)).toBe(true);
       expect(result.length).toBeGreaterThan(0);
 
-      // Check that the first instrument has the expected OC format
+      // Check that the first instrument has the expected structure
       const firstInstrument = result[0];
       expect(firstInstrument).toHaveProperty('id');
       expect(firstInstrument).toHaveProperty('label');
-      expect(firstInstrument.id).toMatch(/^[A-Z]{3}_[A-Z]{3}$/); // OC format: EUR_USD
+      // Instrument IDs are now enum values like 'EURAUD', not 'EUR_AUD'
+      expect(typeof firstInstrument.id).toBe('string');
+      expect(firstInstrument.id.length).toBeGreaterThan(0);
     });
 
     it('should return OAP instrument config for OAP division', () => {
@@ -28,11 +30,13 @@ describe('instrumentUtils', () => {
       expect(Array.isArray(result)).toBe(true);
       expect(result.length).toBeGreaterThan(0);
 
-      // Check that the first instrument has the expected OAP format
+      // Check that the first instrument has the expected structure
       const firstInstrument = result[0];
       expect(firstInstrument).toHaveProperty('id');
       expect(firstInstrument).toHaveProperty('label');
-      expect(firstInstrument.id).toMatch(/^[A-Z]{6}$/); // OAP format: EURUSD
+      // Instrument IDs are now enum values like 'EURAUD', not 'EURUSD'
+      expect(typeof firstInstrument.id).toBe('string');
+      expect(firstInstrument.id.length).toBeGreaterThan(0);
     });
 
     it('should return different configs for different divisions', () => {
@@ -41,12 +45,14 @@ describe('instrumentUtils', () => {
 
       expect(ocConfig).not.toEqual(oapConfig);
 
-      // Check that the instrument IDs have different formats
+      // Both configs should have valid instrument IDs
       const ocFirstId = ocConfig[0].id;
       const oapFirstId = oapConfig[0].id;
 
-      expect(ocFirstId).toMatch(/^[A-Z]{3}_[A-Z]{3}$/);
-      expect(oapFirstId).toMatch(/^[A-Z]{6}$/);
+      expect(typeof ocFirstId).toBe('string');
+      expect(typeof oapFirstId).toBe('string');
+      // OAP config includes XAU_USD and XAG_USD which OC doesn't have
+      expect(oapConfig.length).toBeGreaterThan(ocConfig.length);
     });
   });
 });

package/test/utils/processBuckets.test.ts

@@ -0,0 +1,153 @@
+import { processBuckets } from '../../src/CrowdViewWidget/components';
+import type { GetOrderPositionBooksQuery } from '../../src/gql/types/graphql';
+
+describe('processBuckets', () => {
+  const DEFAULT_BUCKET_WIDTH = 0.0005;
+  const OPTIMIZED_BUCKET_WIDTH = 0.002; // DEFAULT_BUCKET_WIDTH * 4
+
+  const createMockOrderPositionBook = (
+    time: string,
+    buckets: Array<{ price: number; sentiment: number | null } | null>,
+    bucketWidth: number = DEFAULT_BUCKET_WIDTH
+  ) => ({
+    bucketWidth,
+    price: 1.0,
+    time,
+    buckets,
+  });
+
+  it('should return empty array when orderPositionData is undefined', () => {
+    expect(processBuckets(undefined, DEFAULT_BUCKET_WIDTH)).toEqual([]);
+  });
+
+  it('should return empty array when orderPositionBooks is empty', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [],
+    };
+    expect(processBuckets(mockData, DEFAULT_BUCKET_WIDTH)).toEqual([]);
+  });
+
+  it('should filter out null books', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [null, createMockOrderPositionBook('2025-01-01', [])],
+    };
+    expect(processBuckets(mockData, DEFAULT_BUCKET_WIDTH)).toEqual([]);
+  });
+
+  it('should filter out books with no buckets', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', []),
+        createMockOrderPositionBook('2025-01-02', [
+          { price: 1.0, sentiment: 0.2 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual([{ price: 1.0, sentiment: 0.2 }]);
+  });
+
+  it('should filter out null buckets and buckets with missing price or sentiment', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          null,
+          { price: 1.0, sentiment: null },
+          { price: undefined as any, sentiment: 0.2 },
+          { price: 1.1, sentiment: 0.2 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual([{ price: 1.1, sentiment: 0.2 }]);
+  });
+
+  it('should filter out buckets below sentiment threshold', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          { price: 1.0, sentiment: 0.1 }, // below threshold
+          { price: 1.1, sentiment: 0.15 }, // at threshold
+          { price: 1.2, sentiment: 0.2 }, // above threshold
+          { price: 1.3, sentiment: -0.1 }, // below threshold (absolute)
+          { price: 1.4, sentiment: -0.15 }, // at threshold (absolute)
+          { price: 1.5, sentiment: -0.2 }, // above threshold (absolute)
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual([
+      { price: 1.1, sentiment: 0.15 },
+      { price: 1.2, sentiment: 0.2 },
+      { price: 1.4, sentiment: -0.15 },
+      { price: 1.5, sentiment: -0.2 },
+    ]);
+  });
+
+  it('should aggregate buckets when using optimized width', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook(
+          '2025-01-01',
+          [
+            { price: 1.0, sentiment: 0.2 },
+            { price: 1.0003, sentiment: 0.3 },
+            { price: 1.0007, sentiment: 0.1 },
+            { price: 1.0012, sentiment: 0.25 },
+          ],
+          DEFAULT_BUCKET_WIDTH
+        ),
+      ],
+    };
+    const result = processBuckets(mockData, OPTIMIZED_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    // Buckets should be aggregated: 1.0 + 1.0003 + 1.0007 = 1.0 bucket (0.6 sentiment)
+    // 1.0012 = 1.001 bucket (0.25 sentiment)
+    expect(result[0].length).toBeGreaterThan(0);
+    const aggregatedSentiments = result[0].reduce(
+      (acc, bucket) => acc + bucket.sentiment,
+      0
+    );
+    expect(aggregatedSentiments).toBeCloseTo(0.85, 2);
+  });
+
+  it('should not aggregate buckets when using default width', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          { price: 1.0, sentiment: 0.2 },
+          { price: 1.0003, sentiment: 0.3 },
+          { price: 1.0012, sentiment: 0.25 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(1);
+    // Should have same number of buckets as input (assuming all pass threshold)
+    expect(result[0].length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('should process multiple books correctly', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01', [
+          { price: 1.0, sentiment: 0.2 },
+        ]),
+        createMockOrderPositionBook('2025-01-02', [
+          { price: 1.1, sentiment: 0.3 },
+          { price: 1.2, sentiment: 0.4 },
+        ]),
+      ],
+    };
+    const result = processBuckets(mockData, DEFAULT_BUCKET_WIDTH);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual([{ price: 1.0, sentiment: 0.2 }]);
+    expect(result[1]).toEqual([
+      { price: 1.1, sentiment: 0.3 },
+      { price: 1.2, sentiment: 0.4 },
+    ]);
+  });
+});

package/test/utils/processOrderPositionBooks.test.ts

@@ -0,0 +1,127 @@
+import { processOrderPositionBooks } from '../../src/CrowdViewWidget/components';
+import type { GetOrderPositionBooksQuery } from '../../src/gql/types/graphql';
+
+describe('processOrderPositionBooks', () => {
+  const createMockOrderPositionBook = (time: string) => ({
+    bucketWidth: 0.0005,
+    price: 1.0,
+    time,
+    buckets: [{ price: 1.0, sentiment: 0.2 }],
+  });
+
+  it('should return empty array when orderPositionData is undefined', () => {
+    const candleMap = new Map();
+    expect(processOrderPositionBooks(undefined, candleMap)).toEqual([]);
+  });
+
+  it('should return empty array when orderPositionBooks is empty', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [],
+    };
+    const candleMap = new Map();
+    expect(processOrderPositionBooks(mockData, candleMap)).toEqual([]);
+  });
+
+  it('should filter out null books', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [null, createMockOrderPositionBook('2025-01-01')],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+  });
+
+  it('should filter out books with no buckets', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        {
+          bucketWidth: 0.0005,
+          price: 1.0,
+          time: '2025-01-01',
+          buckets: [],
+        },
+        createMockOrderPositionBook('2025-01-02'),
+      ],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-02', null, 0]);
+  });
+
+  it('should use candle high price when available in map', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01'),
+        createMockOrderPositionBook('2025-01-02'),
+      ],
+    };
+    const candleMap = new Map([
+      ['2025-01-01', { high: 1.1234 }],
+      ['2025-01-02', { high: 1.5678 }],
+    ]);
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual(['2025-01-01', 1.1234, 0]);
+    expect(result[1]).toEqual(['2025-01-02', 1.5678, 1]);
+  });
+
+  it('should use null when candle is not in map', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [createMockOrderPositionBook('2025-01-01')],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+  });
+
+  it('should use null when candle high is undefined', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [createMockOrderPositionBook('2025-01-01')],
+    };
+    const candleMap = new Map([
+      ['2025-01-01', { low: 1.0 }], // no high property
+    ]);
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(['2025-01-01', null, 0]);
+  });
+
+  it('should correctly assign index to each book', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01'),
+        createMockOrderPositionBook('2025-01-02'),
+        createMockOrderPositionBook('2025-01-03'),
+      ],
+    };
+    const candleMap = new Map();
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(3);
+    expect(result[0][2]).toBe(0);
+    expect(result[1][2]).toBe(1);
+    expect(result[2][2]).toBe(2);
+  });
+
+  it('should handle mixed cases with and without candles', () => {
+    const mockData: GetOrderPositionBooksQuery = {
+      orderPositionBooks: [
+        createMockOrderPositionBook('2025-01-01'),
+        createMockOrderPositionBook('2025-01-02'),
+        createMockOrderPositionBook('2025-01-03'),
+      ],
+    };
+    const candleMap = new Map([
+      ['2025-01-01', { high: 1.1111 }],
+      // 2025-01-02 missing from map
+      ['2025-01-03', { high: 1.3333 }],
+    ]);
+    const result = processOrderPositionBooks(mockData, candleMap);
+    expect(result).toHaveLength(3);
+    expect(result[0]).toEqual(['2025-01-01', 1.1111, 0]);
+    expect(result[1]).toEqual(['2025-01-02', null, 1]);
+    expect(result[2]).toEqual(['2025-01-03', 1.3333, 2]);
+  });
+});