chore: DH-15527 Move ACL Editor Code to Community (#1490)

Moved ACL Editor util code from Enterprise to Community. This should not
introduce any functional changes.

Supports #1469 and DH-15527

Author: bmingles

package-lock.json

@@ -29,7 +29,6 @@
     "@deephaven/log": "file:../log",
     "@deephaven/react-hooks": "file:../react-hooks",
     "@deephaven/utils": "file:../utils",
-    "@react-stately/data": "^3.9.1",
     "@types/js-cookie": "^3.0.3",
     "classnames": "^2.3.2",
     "js-cookie": "^3.0.5",

packages/jsapi-components/package.json

@@ -4,16 +4,27 @@ export * from './RefreshTokenBootstrap';
 export * from './RefreshTokenUtils';
 export { default as useBroadcastChannel } from './useBroadcastChannel';
 export { default as useBroadcastLoginListener } from './useBroadcastLoginListener';
+export * from './useCheckIfExistsValue';
 export { default as useDebouncedViewportSearch } from './useDebouncedViewportSearch';
+export * from './useDebouncedViewportSelectionFilter';
+export * from './useFilterConditionFactories';
+export * from './useFilteredItemsWithDefaultValue';
+export * from './useGetItemPosition';
 export { default as useInitializeViewportData } from './useInitializeViewportData';
+export * from './useSearchableViewportData';
+export * from './useNotNullOrEmptyFilter';
+export * from './usePickerWithSelectedValues';
+export { default as useSelectDistinctTable } from './useSelectDistinctTable';
+export { default as useSetPaddedViewportCallback } from './useSetPaddedViewportCallback';
+export * from './useShowOnlyEmptyFilter';
 export { default as useTable } from './useTable';
 export { default as useTableColumn } from './useTableColumn';
 export { default as useTableListener } from './useTableListener';
-export { default as useSelectDistinctTable } from './useSelectDistinctTable';
-export { default as useSetPaddedViewportCallback } from './useSetPaddedViewportCallback';
 export { default as useTableClose } from './useTableClose';
 export { default as useTableSize } from './useTableSize';
 export { default as useTableUtils } from './useTableUtils';
+export * from './useValueFilter';
 export { default as useViewportData } from './useViewportData';
 export type { UseSelectDistinctTableResult } from './useSelectDistinctTable';
 export type { UseViewportDataResult } from './useViewportData';
+export * from './useViewportFilter';

packages/jsapi-components/src/index.ts

@@ -0,0 +1,122 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import type { Table } from '@deephaven/jsapi-types';
+import { TableUtils } from '@deephaven/jsapi-utils';
+import { TestUtils } from '@deephaven/utils';
+import useCheckIfExistsValue from './useCheckIfExistsValue';
+import useTableUtils from './useTableUtils';
+
+jest.mock('@deephaven/jsapi-utils');
+jest.mock('./useTableUtils');
+
+const { asMock, createMockProxy } = TestUtils;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  expect.hasAssertions();
+});
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+describe.each([true, false])('useCheckIfExistsValue: %s', valueExists => {
+  const mock = {
+    table: createMockProxy<Table>(),
+    tableUtils: createMockProxy<TableUtils>(),
+    columnNames: ['mock.columnA', 'mock.columnB'],
+    debounceMs: 500,
+  };
+
+  function completeDebounce() {
+    act(() => {
+      jest.advanceTimersByTime(mock.debounceMs);
+    });
+  }
+
+  beforeEach(() => {
+    asMock(useTableUtils)
+      .mockName('useTableUtils')
+      .mockReturnValue(mock.tableUtils);
+
+    asMock(mock.tableUtils.doesColumnValueExist).mockResolvedValue(valueExists);
+  });
+
+  it.each([true, false])(
+    'should check if value exists and return result: isCaseSensitive:%s',
+    async isCaseSensitive => {
+      const { result, waitForNextUpdate } = renderHook(() =>
+        useCheckIfExistsValue(
+          mock.table,
+          mock.columnNames,
+          mock.debounceMs,
+          isCaseSensitive
+        )
+      );
+
+      await waitForNextUpdate();
+
+      expect(mock.tableUtils.doesColumnValueExist).toHaveBeenCalledWith(
+        mock.table,
+        mock.columnNames,
+        '',
+        isCaseSensitive
+      );
+
+      expect(result.current).toEqual({
+        valueTrimmed: '',
+        valueTrimmedDebounced: '',
+        valueExists,
+        trimAndUpdateValue: expect.any(Function),
+      });
+    }
+  );
+
+  it('should treat valueExists as indeterminant while value check is pending', async () => {
+    // eslint-disable-next-line no-promise-executor-return
+    const unresolvedPromise = new Promise<boolean>(() => undefined);
+    asMock(mock.tableUtils.doesColumnValueExist).mockReturnValue(
+      unresolvedPromise
+    );
+
+    const { result, waitForNextUpdate } = renderHook(() =>
+      useCheckIfExistsValue(mock.table, mock.columnNames, mock.debounceMs, true)
+    );
+
+    await waitForNextUpdate();
+
+    expect(result.current).toMatchObject({
+      valueExists: null,
+      valueTrimmed: '',
+      valueTrimmedDebounced: '',
+    });
+  });
+
+  it('should trim search text and treat valueExists as indeterminant while debouncing', async () => {
+    jest.useFakeTimers();
+
+    const { result, waitForNextUpdate } = renderHook(() =>
+      useCheckIfExistsValue(mock.table, mock.columnNames, mock.debounceMs, true)
+    );
+
+    completeDebounce();
+    await waitForNextUpdate();
+
+    act(() => result.current.trimAndUpdateValue('  blah  '));
+
+    // While text change debounce is still settling
+    expect(result.current).toMatchObject({
+      valueExists: null,
+      valueTrimmed: 'blah',
+      valueTrimmedDebounced: '',
+    });
+
+    completeDebounce();
+    await waitForNextUpdate();
+
+    expect(result.current).toMatchObject({
+      valueExists,
+      valueTrimmed: 'blah',
+      valueTrimmedDebounced: 'blah',
+    });
+  });
+});

packages/jsapi-components/src/useCheckIfExistsValue.test.ts

@@ -0,0 +1,68 @@
+import { useCallback, useState } from 'react';
+import type { Table } from '@deephaven/jsapi-types';
+import { useDebouncedValue, usePromiseFactory } from '@deephaven/react-hooks';
+import useTableUtils from './useTableUtils';
+
+export interface CheckIfExistsValue {
+  /** Current trimmed value */
+  valueTrimmed: string;
+
+  /** Debounced trimmed value */
+  valueTrimmedDebounced: string;
+
+  /**
+   * Whether the value exists in the given table columns. Will be null whenever
+   * the value changes until the next check is complete.
+   */
+  valueExists: boolean | null;
+
+  /** Trims and updates the value */
+  trimAndUpdateValue: (value: string) => void;
+}
+
+/**
+ * Manage a trimmed text value and check if it exists in a list of table columns.
+ * @param table The table to check for the value
+ * @param columnNames The column names to check
+ * @param debounceMs Debounce timer for re-checking the value
+ * @param isCaseSensitive Whether the value check is case sensitive
+ */
+export function useCheckIfExistsValue(
+  table: Table | null | undefined,
+  columnNames: string | string[],
+  debounceMs: number,
+  isCaseSensitive: boolean
+): CheckIfExistsValue {
+  const tableUtils = useTableUtils();
+
+  const [valueTrimmed, setValueTrimmed] = useState('');
+  const valueTrimmedDebounced = useDebouncedValue(valueTrimmed, debounceMs);
+
+  const trimAndUpdateValue = useCallback((text: string) => {
+    setValueTrimmed(text.trim());
+  }, []);
+
+  const { data: valueExistsData, isLoading: valueExistsIsLoading } =
+    usePromiseFactory(tableUtils.doesColumnValueExist, [
+      table,
+      columnNames,
+      valueTrimmedDebounced,
+      isCaseSensitive,
+    ]);
+
+  // If value check is loading or if debounce hasn't settled, set
+  // `matchesExistingValue` to null since it is indeterminate
+  const valueExists =
+    valueExistsIsLoading || valueTrimmed !== valueTrimmedDebounced
+      ? null
+      : valueExistsData;
+
+  return {
+    valueTrimmed,
+    valueTrimmedDebounced,
+    valueExists,
+    trimAndUpdateValue,
+  };
+}
+
+export default useCheckIfExistsValue;

packages/jsapi-components/src/useCheckIfExistsValue.ts

@@ -13,8 +13,13 @@ import useDebouncedViewportSearch, {
 } from './useDebouncedViewportSearch';
 import { UseViewportDataResult } from './useViewportData';
 import { makeApiContextWrapper } from './HookTestUtils';
+import useTableUtils from './useTableUtils';
 
-const tableUtils = new TableUtils(dh);
+jest.mock('./useTableUtils');
+
+const { asMock, createMockProxy } = TestUtils;
+
+const tableUtils = createMockProxy<TableUtils>();
 
 const wrapper = makeApiContextWrapper(dh);
 
@@ -38,9 +43,8 @@ beforeEach(() => {
   TestUtils.asMock(columnFilterValue.contains).mockReturnValue(filterCondition);
   TestUtils.asMock(table.findColumn).mockReturnValue(column);
 
-  jest
-    .spyOn(TableUtils.prototype, 'makeFilterValue')
-    .mockReturnValue(matchFilterValue);
+  asMock(useTableUtils).mockName('useTableUtils').mockReturnValue(tableUtils);
+  asMock(tableUtils.makeFilterValue).mockReturnValue(matchFilterValue);
 });
 
 it.each([undefined, 400])(

packages/jsapi-components/src/useDebouncedViewportSearch.test.tsx

@@ -1,10 +1,9 @@
 import debounce from 'lodash.debounce';
 import type { Table, TreeTable } from '@deephaven/jsapi-types';
-import { TableUtils } from '@deephaven/jsapi-utils';
-import { useApi } from '@deephaven/jsapi-bootstrap';
 import Log from '@deephaven/log';
 import { useEffect, useMemo } from 'react';
 import { UseViewportDataResult } from './useViewportData';
+import useTableUtils from './useTableUtils';
 
 const log = Log.module('useDebouncedViewportSearch');
 
@@ -18,16 +17,12 @@ export const DEBOUNCE_VIEWPORT_SEARCH_MS = 200;
  * @param debounceMs Millisecond value to debounce
  * @returns A debounced search function
  */
-export default function useDebouncedViewportSearch<
-  I,
-  T extends Table | TreeTable,
->(
+export function useDebouncedViewportSearch<I, T extends Table | TreeTable>(
   viewportData: UseViewportDataResult<I, T>,
   columnName: string,
   debounceMs = DEBOUNCE_VIEWPORT_SEARCH_MS
 ): (searchText: string) => void {
-  const dh = useApi();
-  const tableUtils = useMemo(() => new TableUtils(dh), [dh]);
+  const tableUtils = useTableUtils();
   const { table, applyFiltersAndRefresh } = viewportData;
 
   const debouncedSearch = useMemo(
@@ -68,3 +63,5 @@ export default function useDebouncedViewportSearch<
 
   return debouncedSearch;
 }
+
+export default useDebouncedViewportSearch;