add tests

src/plugins/charts/public/services/active_cursor/active_cursor.test.ts

@@ -0,0 +1,34 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import { ActiveCursor } from './active_cursor';
+
+describe('ActiveCursor', () => {
+  let activeCursor: ActiveCursor;
+
+  beforeEach(() => {
+    activeCursor = new ActiveCursor();
+  });
+
+  test('should initialize activeCursor$ stream on setup hook', () => {
+    expect(activeCursor.activeCursor$).toBeUndefined();
+
+    activeCursor.setup();
+
+    expect(activeCursor.activeCursor$).toMatchInlineSnapshot(`
+      Subject {
+        "_isScalar": false,
+        "closed": false,
+        "hasError": false,
+        "isStopped": false,
+        "observers": Array [],
+        "thrownError": null,
+      }
+    `);
+  });
+});

src/plugins/charts/public/services/active_cursor/active_cursor_utils.test.ts

@@ -0,0 +1,141 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import { parseSyncOptions } from './active_cursor_utils';
+import { Datatable } from '../../../../expressions';
+
+describe('active_cursor_utils', () => {
+  describe('parseSyncOptions', () => {
+    describe('dateHistogramSyncOption', () => {
+      test('should return isDateHistogram true in case if that mode is active', () => {
+        expect(parseSyncOptions({ isDateHistogram: true })).toMatchInlineSnapshot(`
+          Object {
+            "isDateHistogram": true,
+          }
+        `);
+      });
+
+      test('should return isDateHistogram false for other cases', () => {
+        expect(parseSyncOptions({ datatables: [] as Datatable[] })).toMatchInlineSnapshot(`
+          Object {
+            "accessors": Array [],
+            "isDateHistogram": false,
+          }
+        `);
+      });
+    });
+
+    describe('datatablesSyncOption', () => {
+      test('should extract accessors', () => {
+        expect(
+          parseSyncOptions({
+            datatables: ([
+              {
+                columns: [
+                  {
+                    meta: {
+                      index: 'foo_index',
+                      field: 'foo_field',
+                    },
+                  },
+                ],
+              },
+            ] as unknown) as Datatable[],
+          }).accessors
+        ).toMatchInlineSnapshot(`
+          Array [
+            "foo_index:foo_field",
+          ]
+        `);
+      });
+
+      test('should return isDateHistogram true in case all datatables is time based', () => {
+        expect(
+          parseSyncOptions({
+            datatables: ([
+              {
+                columns: [
+                  {
+                    meta: {
+                      index: 'foo_index',
+                      field: 'foo_field',
+                      sourceParams: {
+                        appliedTimeRange: {},
+                      },
+                    },
+                  },
+                ],
+              },
+              {
+                columns: [
+                  {
+                    meta: {
+                      index: 'foo_index1',
+                      field: 'foo_field1',
+                      sourceParams: {
+                        appliedTimeRange: {},
+                      },
+                    },
+                  },
+                ],
+              },
+            ] as unknown) as Datatable[],
+          })
+        ).toMatchInlineSnapshot(`
+          Object {
+            "accessors": Array [
+              "foo_index:foo_field",
+              "foo_index1:foo_field1",
+            ],
+            "isDateHistogram": true,
+          }
+        `);
+      });
+
+      test('should return isDateHistogram false in case of not all datatables is time based', () => {
+        expect(
+          parseSyncOptions({
+            datatables: ([
+              {
+                columns: [
+                  {
+                    meta: {
+                      index: 'foo_index',
+                      field: 'foo_field',
+                      sourceParams: {
+                        appliedTimeRange: {},
+                      },
+                    },
+                  },
+                ],
+              },
+              {
+                columns: [
+                  {
+                    meta: {
+                      index: 'foo_index1',
+                      field: 'foo_field1',
+                    },
+                  },
+                ],
+              },
+            ] as unknown) as Datatable[],
+          })
+        ).toMatchInlineSnapshot(`
+          Object {
+            "accessors": Array [
+              "foo_index:foo_field",
+              "foo_index1:foo_field1",
+            ],
+            "isDateHistogram": false,
+          }
+        `);
+      });
+    });
+  });
+});

src/plugins/charts/public/services/active_cursor/active_cursor_utils.ts

@@ -9,6 +9,7 @@ import { uniq } from 'lodash';
 
 import type { Datatable } from '../../../../expressions';
 import type { ActiveCursorSyncOption, DateHistogramSyncOption } from './types';
+import { ActiveCursorPayload } from './types';
 
 function isDateHistogramSyncOption(
   syncOption?: ActiveCursorSyncOption
@@ -17,9 +18,11 @@ function isDateHistogramSyncOption(
 }
 
 const parseDatatable = (dataTables: Datatable[]) => {
-  const isDateHistogram = dataTables.every((dataTable) =>
-    dataTable.columns.find((c) => Boolean(c.meta.sourceParams?.appliedTimeRange))
-  );
+  const isDateHistogram =
+    Boolean(dataTables.length) &&
+    dataTables.every((dataTable) =>
+      dataTable.columns.find((c) => Boolean(c.meta.sourceParams?.appliedTimeRange))
+    );
 
   const accessors = uniq(
     dataTables
@@ -36,10 +39,11 @@ const parseDatatable = (dataTables: Datatable[]) => {
 };
 
 /** @internal **/
-export const parseSyncOptions = (syncOptions: ActiveCursorSyncOption) =>
+export const parseSyncOptions = (
+  syncOptions: ActiveCursorSyncOption
+): Partial<ActiveCursorPayload> =>
   isDateHistogramSyncOption(syncOptions)
     ? {
         isDateHistogram: syncOptions.isDateHistogram,
-        accessors: undefined,
       }
     : parseDatatable(syncOptions.datatables);

src/plugins/charts/public/services/active_cursor/use_active_cursor.test.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+import { renderHook } from '@testing-library/react-hooks';
+import type { RefObject } from 'react';
+
+import { ActiveCursor } from './active_cursor';
+import { useActiveCursor } from './use_active_cursor';
+
+import type { ActiveCursorSyncOption, ActiveCursorPayload } from './types';
+import type { Chart, PointerEvent } from '@elastic/charts';
+import { Datatable } from '../../../../expressions';
+
+describe('useActiveCursor', () => {
+  let cursor: ActiveCursorPayload['cursor'];
+  let dispatchExternalPointerEvent: jest.Mock;
+
+  const act = (syncOption: ActiveCursorSyncOption, events: Array<Partial<ActiveCursorPayload>>) =>
+    new Promise((resolve) => {
+      const activeCursor = new ActiveCursor();
+
+      activeCursor.setup();
+
+      dispatchExternalPointerEvent.mockImplementation((pointerEvent) => {
+        resolve(pointerEvent);
+      });
+
+      renderHook(() =>
+        useActiveCursor(
+          activeCursor,
+          {
+            current: {
+              dispatchExternalPointerEvent: dispatchExternalPointerEvent as (
+                pointerEvent: PointerEvent
+              ) => void,
+            },
+          } as RefObject<Chart>,
+          syncOption
+        )
+      );
+
+      events.forEach((event) => {
+        activeCursor.activeCursor$!.next({ cursor, ...event });
+      });
+    });
+
+  beforeEach(() => {
+    cursor = {} as ActiveCursorPayload['cursor'];
+    dispatchExternalPointerEvent = jest.fn();
+  });
+
+  test('should trigger cursor pointer update (chart type: time, event type: time)', async () => {
+    await act({ isDateHistogram: true }, [{ isDateHistogram: true }]);
+
+    expect(dispatchExternalPointerEvent).toHaveBeenCalledTimes(1);
+  });
+
+  test('should trigger cursor pointer update (chart type: datatable - time based, event type: time)', async () => {
+    await act(
+      {
+        datatables: ([
+          {
+            columns: [
+              {
+                meta: {
+                  index: 'foo_index',
+                  field: 'foo_field',
+                  sourceParams: {
+                    appliedTimeRange: {},
+                  },
+                },
+              },
+            ],
+          },
+        ] as unknown) as Datatable[],
+      },
+      [{ isDateHistogram: true }, { accessors: ['foo_index:foo_field'] }]
+    );
+
+    expect(dispatchExternalPointerEvent).toHaveBeenCalledTimes(2);
+  });
+
+  test('should not trigger cursor pointer update (chart type: datatable, event type: time)', async () => {
+    await act(
+      {
+        datatables: [
+          {
+            columns: [
+              {
+                meta: {
+                  index: 'foo_index',
+                  field: 'foo_field',
+                },
+              },
+            ],
+          },
+        ] as Datatable[],
+      },
+      [{ isDateHistogram: true }, { accessors: ['foo_index:foo_field'] }]
+    );
+
+    expect(dispatchExternalPointerEvent).toHaveBeenCalledTimes(1);
+  });
+
+  test('should works with multi datatables (intersection)', async () => {
+    await act(
+      {
+        datatables: [
+          {
+            columns: [
+              {
+                meta: {
+                  index: 'ia',
+                  field: 'fa',
+                },
+              },
+            ],
+          },
+          {
+            columns: [
+              {
+                meta: {
+                  index: 'ib',
+                  field: 'fb',
+                },
+              },
+            ],
+          },
+        ] as Datatable[],
+      },
+      [{ accessors: ['foo_index:foo_field', 'ib:fb'] }]
+    );
+
+    expect(dispatchExternalPointerEvent).toHaveBeenCalledTimes(1);
+  });
+});