opentiny 6.9.0 → 6.9.1

package/src/themes/silver/test/ts/module/StickyHeaderUtils.ts

@@ -1,250 +0,0 @@
-import { ApproxStructure, Assertions, Keyboard, Keys, StructAssert, UiFinder, Waiter } from '@ephox/agar';
-import { Arr, Fun } from '@ephox/katamari';
-import { Css, Focus, Scroll, SugarBody, SugarDocument, SugarElement } from '@ephox/sugar';
-import { assert } from 'chai';
-
-import { ToolbarLocation } from 'tinymce/themes/silver/api/Options';
-
-const staticPartsOuter = (s: ApproxStructure.StructApi, arr: ApproxStructure.ArrayApi): StructAssert[] =>
-  // should not change
-  [
-    s.element('div', {
-      classes: [ arr.has('tox-sidebar-wrap') ]
-    })
-  ];
-
-const statusbar = (s: ApproxStructure.StructApi, arr: ApproxStructure.ArrayApi): StructAssert[] =>
-  // should not change
-  [
-    s.element('div', {
-      classes: [ arr.has('tox-statusbar') ]
-    })
-  ];
-
-const bottomAnchorbar = (s: ApproxStructure.StructApi, arr: ApproxStructure.ArrayApi): StructAssert[] =>
-  // should not change
-  [
-    s.element('div', {
-      classes: [ arr.has('tox-bottom-anchorbar') ]
-    })
-  ];
-
-const staticPartsInner = (s: ApproxStructure.StructApi, arr: ApproxStructure.ArrayApi): StructAssert[] =>
-  // should not change
-  [
-    s.element('div', {
-      classes: [ arr.has('tox-menubar') ]
-    }),
-    s.element('div', {}),
-    s.element('div', {
-      classes: [ arr.has('tox-anchorbar') ]
-    })
-  ];
-
-const expectedScrollEventBound = (s: ApproxStructure.StructApi, str: ApproxStructure.StringApi, arr: ApproxStructure.ArrayApi): StructAssert[] => [
-  s.element('div', {
-    classes: [
-      arr.has('tox-editor-header')
-    ],
-    children: staticPartsInner(s, arr)
-  })
-];
-
-const pAssertHeaderDocked = async (assertDockedTop: boolean): Promise<void> => {
-  const header = UiFinder.findIn(SugarBody.body(), '.tox-editor-header').getOrDie();
-  await Waiter.pTryUntil(
-    'Wait for header structure',
-    () => Assertions.assertStructure(
-      `Header should be docked to ${assertDockedTop ? 'top' : 'bottom'}`,
-      ApproxStructure.build((s, str, _arr) => s.element('div', {
-        styles: {
-          position: str.is('fixed'),
-          ...assertDockedTop ?
-            { top: str.is('0px') } :
-            { bottom: str.is('0px') }
-        }
-      })),
-      header
-    )
-  );
-};
-
-const expectedHalfView = (s: ApproxStructure.StructApi, str: ApproxStructure.StringApi, arr: ApproxStructure.ArrayApi): StructAssert[] => [
-  s.element('div', {
-    classes: [
-      arr.has('tox-editor-header'),
-      arr.not('tox-editor-dock-fadeout')
-    ],
-    styles: {
-      position: str.contains('fixed'),
-      width: str.is('496px') // 500px - 2px for each border
-      // testing left value maybe flaky
-    },
-    children: staticPartsInner(s, arr)
-  })
-];
-
-const expectedEditorHidden = (s: ApproxStructure.StructApi, str: ApproxStructure.StringApi, arr: ApproxStructure.ArrayApi): StructAssert[] => [
-  s.element('div', {
-    classes: [
-      arr.has('tox-editor-header'),
-      arr.has('tox-editor-dock-fadeout'),
-      arr.not('tox-editor-dock-fadein')
-    ],
-    styles: {
-      position: str.contains('fixed'),
-      width: str.is('496px') // 500px - 2px for each border
-      // testing left value maybe flaky
-    },
-    children: staticPartsInner(s, arr)
-  })
-];
-
-const expectedInFullView = (s: ApproxStructure.StructApi, str: ApproxStructure.StringApi, arr: ApproxStructure.ArrayApi): StructAssert[] => [
-  s.element('div', {
-    classes: [
-      arr.has('tox-editor-header'),
-      arr.not('tox-editor-dock-fadeout')
-    ],
-    styles: {
-      position: str.none(),
-      width: str.none()
-    },
-    children: staticPartsInner(s, arr)
-  })
-];
-
-const scrollRelativeEditor = (delta: number, scrollRelativeTop: boolean): void => {
-  const container = UiFinder.findIn(SugarBody.body(), '.tox-tinymce').getOrDie();
-  container.dom.scrollIntoView(scrollRelativeTop);
-  Scroll.to(0, window.pageYOffset + (scrollRelativeTop ? delta : -delta));
-};
-
-const pAssertSinkVisibility = async (label: string, expectedVisibility: 'hidden' | 'visible'): Promise<void> => {
-  const sink = UiFinder.findIn(SugarBody.body(), '.tox-tinymce-aux').getOrDie();
-  await Waiter.pTryUntil(`Wait for sink visibility to be ${expectedVisibility}`, () => {
-    const visibility = Css.get(sink, 'visibility');
-    assert.equal(visibility, expectedVisibility, label);
-  });
-};
-
-const pAssertMenuStructure = (label: string, container: SugarElement<HTMLElement>, position: string): Promise<void> => Waiter.pTryUntil(
-  `Wait until menus become ${position} positioned`,
-  () => Assertions.assertStructure(
-    label,
-    ApproxStructure.build((s, str, arr) => s.element('div', {
-      classes: [ arr.has('tox-menu') ],
-      styles: {
-        position: str.is(position)
-      }
-    })),
-    container
-  )
-);
-
-// Assume editor height 400
-const pTestMenuScroll = async (top: boolean): Promise<void> => {
-  const menu = UiFinder.findIn<HTMLElement>(SugarBody.body(), '[role="menu"]').getOrDie();
-  await pAssertMenuStructure('Checking the opened menus default positioning', menu, 'absolute');
-  scrollRelativeEditor(200, top);
-  await pAssertMenuStructure('When the top of the editor scrolls off screen, menus should become sticky', menu, 'fixed');
-  scrollRelativeEditor(500, top);
-  await pAssertSinkVisibility('When the editor is scrolled off the screen, sticky menus and toolbars should become HIDDEN', 'hidden');
-  scrollRelativeEditor(200, top);
-  await pAssertSinkVisibility('When the editor is partially scrolled on screen, sticky menus and toolbars should become VISIBLE', 'visible');
-  await pAssertMenuStructure('When the editor is partially viewable, it should still be sticky', menu, 'fixed');
-  scrollRelativeEditor(-100, top);
-  await pAssertMenuStructure('When the editor is in full view, menus and toolbars should not be sticky', menu, 'absolute');
-};
-
-const pAssertEditorContainer = async (isToolbarTop: boolean, expectedPart: ApproxStructure.Builder<StructAssert[]>): Promise<void> => {
-  const container = UiFinder.findIn(SugarBody.body(), '.tox-editor-container').getOrDie();
-  await Waiter.pTryUntil('Wait for editor structure',
-    () => Assertions.assertStructure(
-      'for the .tox-editor-container',
-      ApproxStructure.build((s, str, arr) => s.element('div', {
-        classes: [ arr.has('tox-editor-container') ],
-        children: isToolbarTop ?
-          expectedPart(s, str, arr).concat(staticPartsOuter(s, arr)).concat(bottomAnchorbar(s, arr)).concat(statusbar(s, arr)) :
-          staticPartsOuter(s, arr).concat(expectedPart(s, str, arr)).concat(bottomAnchorbar(s, arr)).concat(statusbar(s, arr))
-      })),
-      container
-    )
-  );
-};
-
-const pScrollAndAssertStructure = async (isToolbarTop: boolean, scrollYDelta: number, expectedPart: ApproxStructure.Builder<StructAssert[]>): Promise<void> => {
-  scrollRelativeEditor(scrollYDelta, isToolbarTop);
-  const container = UiFinder.findIn(SugarBody.body(), '.tox-editor-container').getOrDie();
-  await Waiter.pTryUntil('Wait until editor docking updated',
-    () => Assertions.assertStructure(
-      'for the .tox-editor-container',
-      ApproxStructure.build((s, str, arr) => s.element('div', {
-        classes: [ arr.has('tox-editor-container') ],
-        children: isToolbarTop ?
-          expectedPart(s, str, arr).concat(staticPartsOuter(s, arr)).concat(bottomAnchorbar(s, arr)).concat(statusbar(s, arr)) :
-          staticPartsOuter(s, arr).concat(expectedPart(s, str, arr)).concat(bottomAnchorbar(s, arr)).concat(statusbar(s, arr))
-      })),
-      container
-    )
-  );
-};
-
-const assertEditorClasses = (docked: boolean): void => {
-  const container = UiFinder.findIn(SugarBody.body(), '.tox-tinymce').getOrDie();
-  Assertions.assertStructure('Check root container classes', ApproxStructure.build((s, _str, arr) => s.element('div', {
-    classes: [
-      arr.has('tox-tinymce--toolbar-sticky-' + (docked ? 'on' : 'off')),
-      arr.not('tox-tinymce--toolbar-sticky-' + (docked ? 'off' : 'on'))
-    ]
-  })), container);
-};
-
-const pAssertHeaderPosition = async (toolbarLocation: ToolbarLocation, value: number): Promise<void> => {
-  const isToolbarTop = toolbarLocation === ToolbarLocation.top;
-  scrollRelativeEditor(-100, isToolbarTop);
-  await Waiter.pWait(100);
-  scrollRelativeEditor(200, isToolbarTop);
-  const header = UiFinder.findIn(SugarBody.body(), '.tox-editor-header').getOrDie();
-
-  return Waiter.pTryUntil(
-    `Wait until head get ${value}px`,
-    () => assert.equal(Css.get(header, toolbarLocation), `${value}px`)
-  );
-};
-
-const pCloseMenus = (numOpenedMenus: number) => {
-  const menuArray = Arr.range(numOpenedMenus, Fun.identity);
-  return Arr.foldl(menuArray, (p) => p.then(async () => {
-    const menuElem = await UiFinder.pWaitForVisible('Wait for selected menu to be visible', SugarBody.body(), '.tox-selected-menu');
-    await Waiter.pTryUntil('Wait for menu item to be focused', () => {
-      assert.isTrue(Focus.search(menuElem).isSome(), 'Assert menu item is focused');
-    });
-    const focusedElem = Focus.active(SugarDocument.getDocument()).getOrDie('Could not find active menu item');
-    Keyboard.keyup(Keys.escape(), { }, focusedElem);
-    await Waiter.pTryUntil('Wait for menu to be closed', () => {
-      assert.isFalse(SugarBody.inBody(menuElem), 'Assert menu has been closed');
-    });
-  }), Promise.resolve());
-};
-
-const pOpenMenuAndTestScrolling = async (pOpenMenu: () => Promise<void>, numMenusToClose: number, top: boolean): Promise<void> => {
-  await pOpenMenu();
-  await pTestMenuScroll(top);
-  await pCloseMenus(numMenusToClose);
-};
-
-export {
-  expectedHalfView,
-  expectedInFullView,
-  expectedEditorHidden,
-  expectedScrollEventBound,
-
-  pAssertEditorContainer,
-  pOpenMenuAndTestScrolling,
-  pScrollAndAssertStructure,
-  pAssertHeaderDocked,
-  pAssertHeaderPosition,
-  assertEditorClasses,
-  scrollRelativeEditor
-};

package/src/themes/silver/test/ts/module/TestBackstage.ts

@@ -1,88 +0,0 @@
-import { AlloyComponent, GuiFactory, HotspotAnchorSpec, TooltippingTypes } from '@ephox/alloy';
-import { Cell, Fun, Future, Optional, Result } from '@ephox/katamari';
-import { SugarBody } from '@ephox/sugar';
-
-import { UiFactoryBackstage } from 'tinymce/themes/silver/backstage/Backstage';
-import { ApiUrlData } from 'tinymce/themes/silver/backstage/UrlInputBackstage';
-
-import TestProviders from './TestProviders';
-
-export default (sink?: AlloyComponent): UiFactoryBackstage => {
-  // NOTE: Non-sensical anchor
-  const hotspotAnchorFn = (): HotspotAnchorSpec => ({
-    type: 'hotspot',
-    hotspot: sink as AlloyComponent
-  });
-  const headerLocation = Cell<'top' | 'bottom'>('top');
-  const contextMenuState = Cell(false);
-
-  const getTooltipComponents = () => [
-    {
-      dom: {
-        tag: 'div',
-      },
-      components: [
-        GuiFactory.text('Test')
-      ]
-    }
-  ];
-
-  return {
-    shared: {
-      providers: {
-        ...TestProviders,
-        tooltips: {
-          getConfig: (): TooltippingTypes.TooltippingConfigSpec => {
-            return {
-              lazySink: () => Result.value(sink),
-              tooltipDom: { tag: 'div' },
-              tooltipComponents: () => getTooltipComponents(),
-            } as any;
-          },
-          getComponents: getTooltipComponents,
-        }},
-      interpreter: Fun.identity as any,
-      anchors: {
-        inlineDialog: hotspotAnchorFn,
-        inlineBottomDialog: hotspotAnchorFn,
-        banner: hotspotAnchorFn,
-        cursor: () => ({
-          type: 'selection',
-          root: SugarBody.body()
-        }),
-        node: (elem) => ({
-          type: 'node',
-          root: SugarBody.body(),
-          node: elem
-        })
-      },
-      header: {
-        isPositionedAtTop: () => headerLocation.get() !== 'bottom',
-        getDockingMode: headerLocation.get,
-        setDockingMode: headerLocation.set
-      },
-      getSink: () => sink ? Result.value(sink) : Result.error('No test sink setup')
-    },
-    urlinput: {
-      getHistory: Fun.constant([]),
-      addToHistory: Fun.noop,
-      getLinkInformation: Optional.none,
-      getValidationHandler: Optional.none,
-      getUrlPicker: (_filetype) => Optional.some((entry: ApiUrlData) => Future.pure(entry))
-    },
-    styles: {
-      getData: Fun.constant([])
-    },
-    colorinput: {
-      colorPicker: Fun.noop,
-      hasCustomColors: Fun.never,
-      getColors: Fun.constant([]),
-      getColorCols: Fun.constant(5)
-    },
-    dialog: {
-      isDraggableModal: Fun.never
-    },
-    setContextMenuState: contextMenuState.set,
-    isContextMenuOpen: contextMenuState.get
-  };
-};

package/src/themes/silver/test/ts/module/TestExtras.ts

@@ -1,149 +0,0 @@
-import { Attachment, Behaviour, DomFactory, Gui, GuiFactory, Positioning } from '@ephox/alloy';
-import { after, afterEach, before } from '@ephox/bedrock-client';
-import { Fun, Optional } from '@ephox/katamari';
-import { Class, SugarBody, SugarElement } from '@ephox/sugar';
-
-import Editor from 'tinymce/core/api/Editor';
-import { UiFactoryBackstagePair } from 'tinymce/themes/silver/backstage/Backstage';
-
-import TestBackstage from './TestBackstage';
-
-export interface TestExtras {
-  readonly extras: {
-    readonly editor: Editor;
-    readonly backstages: UiFactoryBackstagePair;
-  };
-  readonly destroy: () => void;
-  readonly mockEditor: Editor;
-  readonly getPopupSink: () => SugarElement<HTMLElement>;
-  readonly getPopupMothership: () => Gui.GuiSystem;
-  readonly getDialogSink: () => SugarElement<HTMLElement>;
-}
-
-interface BddTestExtrasHook {
-  readonly access: () => TestExtras;
-}
-
-export const TestExtras = (): TestExtras => {
-
-  const oldSink = document.querySelectorAll('.mce-silver-sink');
-  if (oldSink.length > 0) {
-    throw Error('old sinks found, a previous test did not call helpers.destroy() leaving artifacts, found: ' + oldSink.length);
-  }
-
-  const dialogSink = GuiFactory.build({
-    dom: DomFactory.fromHtml('<div class="mce-silver-sink test-dialogs-sink"></div>'),
-    behaviours: Behaviour.derive([
-      Positioning.config({
-        useFixed: Fun.always
-      })
-    ])
-  });
-
-  const popupSink = GuiFactory.build({
-    dom: DomFactory.fromHtml('<div class="mce-silver-sink test-popups-sink"></div>'),
-    behaviours: Behaviour.derive([
-      Positioning.config({
-        useFixed: Fun.always
-      })
-    ])
-  });
-
-  const dialogMothership = Gui.create();
-  Class.add(dialogMothership.element, 'tox');
-  Class.add(dialogMothership.element, 'test-dialogs-mothership');
-
-  const popupMothership = Gui.create();
-  Class.add(popupMothership.element, 'tox');
-  Class.add(popupMothership.element, 'test-popups-mothership');
-
-  const backstages = {
-    popup: TestBackstage(popupSink),
-    dialog: TestBackstage(dialogSink)
-  };
-  const options: Record<string, any> = {};
-
-  const editorOn: Editor['on'] = (_name, _callback) => {
-    return { } as any;
-  };
-
-  const editorOff: Editor['off'] = (_name, _callback) => {
-    return { } as any;
-  };
-
-  const mockEditor = {
-    setContent: (_content) => {},
-    on: editorOn,
-    off: editorOff,
-    insertContent: (_content: string, _args?: any) => {},
-    execCommand: (_cmd: string, _ui?: boolean, _value?: any) => {},
-    getContainer: () => SugarBody.body().dom,
-    getContentAreaContainer: () => SugarBody.body().dom,
-    ui: {
-      show: Fun.noop
-    },
-    options: {
-      get: (name: string) => options[name]
-    }
-  } as Editor;
-
-  const extras = {
-    editor: mockEditor,
-    backstages
-  };
-
-  dialogMothership.add(dialogSink);
-  popupMothership.add(popupSink);
-  Attachment.attachSystem(SugarBody.body(), dialogMothership);
-  Attachment.attachSystem(SugarBody.body(), popupMothership);
-
-  const getPopupSink = () => popupSink.element;
-  const getDialogSink = () => dialogSink.element;
-  const getPopupMothership = Fun.constant(popupMothership);
-
-  const destroy = () => {
-    dialogMothership.remove(dialogSink);
-    dialogMothership.destroy();
-    popupMothership.remove(popupSink);
-    popupMothership.destroy();
-  };
-
-  return {
-    extras,
-    destroy,
-    mockEditor,
-    getPopupSink,
-    getDialogSink,
-    getPopupMothership
-  };
-};
-
-export const bddSetup = (): BddTestExtrasHook => {
-  let helpers: Optional<TestExtras> = Optional.none();
-  let hasFailure = false;
-
-  before(() => {
-    helpers = Optional.some(TestExtras());
-  });
-
-  afterEach(function () {
-    if (this.currentTest?.isFailed() === true) {
-      hasFailure = true;
-    }
-  });
-
-  after(() => {
-    if (!hasFailure) {
-      helpers.each((h) => h.destroy());
-      helpers = Optional.none();
-    }
-  });
-
-  const access = (): TestExtras => helpers.getOrDie(
-    'The setup hooks have not run yet'
-  );
-
-  return {
-    access
-  };
-};

package/src/themes/silver/test/ts/module/TestProviders.ts

@@ -1,25 +0,0 @@
-import { TooltippingTypes } from '@ephox/alloy';
-import { Fun } from '@ephox/katamari';
-
-import I18n from 'tinymce/core/api/util/I18n';
-import { UiFactoryBackstageProviders } from 'tinymce/themes/silver/backstage/Backstage';
-
-const defaultOptions: Record<string, any> = {
-  images_file_types: 'jpeg,jpg,jpe,jfi,jif,jfif,png,gif,bmp,webp'
-};
-
-export default {
-  icons: (): Record<string, string> => ({}),
-  menuItems: (): Record<string, any> => ({}),
-  translate: I18n.translate,
-  isDisabled: Fun.never,
-  getOption: <T>(name: string): T | undefined => defaultOptions[name],
-  tooltips: {
-    getConfig: (): TooltippingTypes.TooltippingConfigSpec => {
-      return { } as any;
-    },
-    getComponents: () => {
-      return [] as any;
-    },
-  }
-} as UiFactoryBackstageProviders;

package/src/themes/silver/test/ts/module/ToolbarUtils.ts

@@ -1,44 +0,0 @@
-import { Waiter } from '@ephox/agar';
-import { Type } from '@ephox/katamari';
-import { Height, SugarElement, SugarLocation, Width } from '@ephox/sugar';
-import { TinyUiActions } from '@ephox/wrap-mcagar';
-import { assert } from 'chai';
-
-import Editor from 'tinymce/core/api/Editor';
-import { ToolbarMode } from 'tinymce/themes/silver/api/Options';
-
-import { pCloseMore, pOpenMore } from './MenuUtils';
-
-const pAssertFloatingToolbarPosition = async (editor: Editor, getTop: () => number, expectedLeft: number, expectedRight: number): Promise<void> => {
-  const toolbar = await TinyUiActions.pWaitForUi(editor, '.tox-toolbar__overflow') as SugarElement<HTMLElement>;
-  await Waiter.pTryUntil('Wait for toolbar position', () => {
-    const top = getTop();
-    const diff = 10;
-    const pos = SugarLocation.absolute(toolbar);
-    const right = pos.left + Width.get(toolbar);
-    assert.approximately(pos.top, top, diff, `Drawer top position ${pos.top}px should be ~${top}px`);
-    assert.approximately(pos.left, expectedLeft, diff, `Drawer left position ${pos.left}px should be ~${expectedLeft}px`);
-    assert.approximately(right, expectedRight, diff, `Drawer right position ${right}px should be ~${expectedRight}px`);
-  });
-};
-
-const pAssertFloatingToolbarHeight = async (editor: Editor, expectedHeight: number): Promise<void> => {
-  const toolbar = await TinyUiActions.pWaitForUi(editor, '.tox-toolbar__overflow') as SugarElement<HTMLElement>;
-  const height = Height.get(toolbar);
-  assert.approximately(height, expectedHeight, 1, `Drawer height ${height}px should be ~${expectedHeight}px`);
-};
-
-const pOpenFloatingToolbarAndAssertPosition = async (editor: Editor, getTop: () => number, pActions?: () => Promise<void>): Promise<void> => {
-  await pOpenMore(ToolbarMode.floating);
-  await pAssertFloatingToolbarPosition(editor, getTop, 105, 531);
-  if (Type.isNonNullable(pActions)) {
-    await pActions();
-  }
-  await pCloseMore(ToolbarMode.floating);
-};
-
-export {
-  pAssertFloatingToolbarHeight,
-  pAssertFloatingToolbarPosition,
-  pOpenFloatingToolbarAndAssertPosition
-};

package/src/themes/silver/test/ts/module/TooltipUtils.ts

@@ -1,62 +0,0 @@
-import { FocusTools, Mouse, UiFinder, Waiter } from '@ephox/agar';
-import { SelectorFilter, SugarBody, SugarElement, TextContent } from '@ephox/sugar';
-import { TinyUiActions } from '@ephox/wrap-mcagar';
-import { assert } from 'chai';
-
-import Editor from 'tinymce/core/api/Editor';
-
-const tooltipSelector = '.tox-silver-sink .tox-tooltip__body';
-
-const pAssertTooltip = async (editor: Editor, pTriggerTooltip: () => Promise<void>, text: string): Promise<void> => {
-  await pTriggerTooltip();
-  const tooltip = await TinyUiActions.pWaitForUi(editor, tooltipSelector) as SugarElement<HTMLElement>;
-  assert.equal(TextContent.get(tooltip), text);
-  assert.equal(SelectorFilter.all(tooltipSelector).length, 1);
-};
-
-const pAssertNoTooltip = async (_: Editor, pTriggerTooltip: () => Promise<void>, _text: string): Promise<void> => {
-  await pTriggerTooltip();
-  await Waiter.pWait(300);
-  UiFinder.notExists(SugarBody.body(), tooltipSelector);
-};
-
-const pTriggerTooltipWithMouse = async (editor: Editor, selector: string): Promise<void> => {
-  const button = await TinyUiActions.pWaitForUi(editor, selector) as SugarElement<HTMLElement>;
-  Mouse.mouseOver(button);
-};
-
-const pTriggerTooltipWithKeyboard = (_: Editor, selector: string): Promise<void> => {
-  FocusTools.setFocus(SugarBody.body(), selector);
-  return Promise.resolve();
-};
-
-const pCloseTooltip = async (editor: Editor, selector: string): Promise<void> => {
-  const button = await TinyUiActions.pWaitForUi(editor, selector) as SugarElement<HTMLElement>;
-  Mouse.mouseOut(button);
-  editor.focus();
-  await Waiter.pTryUntil(
-    'Waiting for tooltip to NO LONGER be in DOM',
-    () => UiFinder.notExists(SugarBody.body(), tooltipSelector));
-};
-
-const pCloseMenu = (selector: string): Promise<void> => {
-  Mouse.clickOn(SugarBody.body(), selector);
-  return Waiter.pTryUntil('Waiting for menu', () =>
-    UiFinder.notExists(SugarBody.body(), '[role="menu"]')
-  );
-};
-
-const pOpenMenu = (editor: Editor, buttonSelector: string): Promise<SugarElement<HTMLElement>> => {
-  TinyUiActions.clickOnToolbar(editor, buttonSelector);
-  return TinyUiActions.pWaitForPopup(editor, '[role="menu"]');
-};
-
-export {
-  pAssertTooltip,
-  pAssertNoTooltip,
-  pTriggerTooltipWithMouse,
-  pTriggerTooltipWithKeyboard,
-  pCloseTooltip,
-  pCloseMenu,
-  pOpenMenu
-};

package/src/themes/silver/test/ts/module/UiUtils.ts

@@ -1,55 +0,0 @@
-import { Mouse, UiFinder, Waiter } from '@ephox/agar';
-import { Arr } from '@ephox/katamari';
-import { Scroll, SugarBody, SugarElement } from '@ephox/sugar';
-import { TinyDom } from '@ephox/wrap-mcagar';
-
-import Editor from 'tinymce/core/api/Editor';
-
-const countNumber = (container: SugarElement<Node>, selector: string): number => {
-  const ts = UiFinder.findAllIn(container, selector);
-  return ts.length;
-};
-
-const extractOnlyOne = (container: SugarElement<Node>, selector: string): SugarElement<HTMLElement> => {
-  const ts = UiFinder.findAllIn<HTMLElement>(container, selector);
-  if (ts.length === 1) {
-    return ts[0];
-  } else {
-    throw new Error('Did not find exactly 1 of ' + selector + '. Found: ' + ts.length);
-  }
-};
-
-const resizeToPos = (sx: number, sy: number, dx: number, dy: number, delta: number = 10): void => {
-  // Simulate moving the mouse, by making a number of movements
-  const numMoves = sy === dy ? Math.abs(dx - sx) / delta : Math.abs(dy - sy) / delta;
-  // Determine the deltas based on the number of moves to make
-  const deltaX = (dx - sx) / numMoves;
-  const deltaY = (dy - sy) / numMoves;
-  // Move and release the mouse
-  const blocker = UiFinder.findIn(SugarBody.body(), '.tox-blocker').getOrDie();
-  Mouse.mouseMoveTo(blocker, sx, sy);
-  Arr.range(numMoves, (count) => {
-    const nx = sx + count * deltaX;
-    const ny = sy + count * deltaY;
-    return Mouse.mouseMoveTo(blocker, nx, ny);
-  });
-  Mouse.mouseMoveTo(blocker, dx, dy);
-  Mouse.mouseUp(blocker);
-};
-
-const scrollRelativeEditor = (editor: Editor, relative: 'top' | 'bottom' = 'top', deltaY: number): void => {
-  const target = editor.inline ? TinyDom.body(editor) : TinyDom.container(editor);
-  target.dom.scrollIntoView(relative === 'top');
-  Scroll.to(0, window.pageYOffset + deltaY);
-};
-
-const pWaitForEditorToRender = (): Promise<void> =>
-  Waiter.pTryUntil('Editor has rendered', () => UiFinder.exists(SugarBody.body(), '.tox-editor-header'));
-
-export {
-  countNumber,
-  extractOnlyOne,
-  resizeToPos,
-  scrollRelativeEditor,
-  pWaitForEditorToRender
-};