@ionic/core 7.5.6-dev.11700169088.140f3e6a → 7.5.6-dev.11700492285.1581ed02

package/dist/collection/utils/animation/test/animation.spec.js

@@ -0,0 +1,431 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { createAnimation } from "../animation";
+import { processKeyframes } from "../animation-utils";
+import { getTimeGivenProgression } from "../cubic-bezier";
+describe('Animation Class', () => {
+  describe('play()', () => {
+    it('should resolve when the animation is cancelled', async () => {
+      // Tell Jest to expect 1 assertion for async code
+      expect.assertions(1);
+      const el = document.createElement('div');
+      const animation = createAnimation()
+        .addElement(el)
+        .fromTo('transform', 'translateX(0px)', 'translateX(100px)')
+        .duration(100000);
+      const animationPromise = animation.play();
+      animation.stop();
+      // Expect that the promise resolves and returns undefined
+      expect(animationPromise).resolves.toEqual(undefined);
+    });
+  });
+  describe('isRunning()', () => {
+    let animation;
+    beforeEach(() => {
+      animation = createAnimation();
+    });
+    it('should not be running initially', () => {
+      expect(animation.isRunning()).toEqual(false);
+    });
+    it('should not be running due to not having keyframes', () => {
+      animation.play();
+      expect(animation.isRunning()).toEqual(false);
+    });
+    it('should be running', () => {
+      const el = document.createElement('div');
+      animation.addElement(el);
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      animation.duration(250);
+      animation.play();
+      expect(animation.isRunning()).toEqual(true);
+    });
+    it('should not be running after finishing the animation', async () => {
+      const el = document.createElement('div');
+      animation.addElement(el);
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      animation.duration(250);
+      await animation.play();
+      expect(animation.isRunning()).toEqual(false);
+    });
+    it('should not be running after calling pause', () => {
+      const el = document.createElement('div');
+      animation.addElement(el);
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      animation.duration(250);
+      animation.play();
+      expect(animation.isRunning()).toEqual(true);
+      animation.pause();
+      expect(animation.isRunning()).toEqual(false);
+    });
+    it('should not be running when doing progress steps', () => {
+      const el = document.createElement('div');
+      animation.addElement(el);
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      animation.duration(250);
+      animation.play();
+      animation.progressStart();
+      expect(animation.isRunning()).toEqual(false);
+    });
+    it('should be running after calling progressEnd', () => {
+      const el = document.createElement('div');
+      animation.addElement(el);
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      animation.duration(250);
+      animation.play();
+      animation.progressStart();
+      animation.progressEnd(1, 0);
+      expect(animation.isRunning()).toEqual(true);
+    });
+    it('should not be running after playing to beginning', async () => {
+      const el = document.createElement('div');
+      animation.addElement(el);
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      animation.duration(250);
+      await animation.play();
+      animation.progressStart();
+      animation.progressEnd(0, 0);
+      await new Promise((resolve) => {
+        animation.onFinish(() => {
+          expect(animation.isRunning()).toEqual(false);
+          resolve();
+        });
+      });
+    });
+  });
+  describe('addElement()', () => {
+    let animation;
+    beforeEach(() => {
+      animation = createAnimation();
+    });
+    it('should add 1 element', () => {
+      const el = document.createElement('p');
+      animation.addElement(el);
+      expect(animation.elements.length).toEqual(1);
+    });
+    it('should add multiple elements', () => {
+      const els = [document.createElement('p'), document.createElement('p'), document.createElement('p')];
+      animation.addElement(els);
+      expect(animation.elements.length).toEqual(els.length);
+    });
+    it('should not error when trying to add null or undefined', () => {
+      const el = document.createElement('p');
+      animation.addElement(el);
+      animation.addElement(null);
+      animation.addElement(undefined);
+      expect(animation.elements.length).toEqual(1);
+    });
+  });
+  describe('addAnimation()', () => {
+    let animation;
+    beforeEach(() => {
+      animation = createAnimation();
+    });
+    it('should add 1 animation', () => {
+      const newAnimation = createAnimation();
+      animation.addAnimation(newAnimation);
+      expect(animation.childAnimations.length).toEqual(1);
+    });
+    it('should add multiple animations', () => {
+      animation.addAnimation([createAnimation(), createAnimation(), createAnimation()]);
+      expect(animation.childAnimations.length).toEqual(3);
+    });
+    it('should not error when trying to add null or undefined', () => {
+      animation.addAnimation(null);
+      animation.addAnimation(undefined);
+      expect(animation.childAnimations.length).toEqual(0);
+    });
+  });
+  describe('Animation Keyframes', () => {
+    let animation;
+    beforeEach(() => {
+      animation = createAnimation();
+    });
+    it('should generate a keyframe', () => {
+      animation.keyframes([
+        { transform: 'scale(1)', opacity: 1, offset: 0 },
+        { transform: 'scale(0.5)', opacity: 0.5, offset: 0.5 },
+        { transform: 'scale(0)', opacity: 0, offset: 1 },
+      ]);
+      expect(animation.getKeyframes().length).toEqual(3);
+    });
+    it('should convert properties for CSS Animations', () => {
+      const processedKeyframes = processKeyframes([
+        { borderRadius: '0px', easing: 'ease-in', offset: 0 },
+        { borderRadius: '4px', easing: 'ease-out', offset: 1 },
+      ]);
+      expect(processedKeyframes).toEqual([
+        { 'border-radius': '0px', 'animation-timing-function': 'ease-in', offset: 0 },
+        { 'border-radius': '4px', 'animation-timing-function': 'ease-out', offset: 1 },
+      ]);
+    });
+    it('should set the from keyframe properly', () => {
+      animation.from('opacity', 0).from('background', 'red').from('color', 'purple');
+      const keyframes = animation.getKeyframes();
+      expect(keyframes.length).toEqual(1);
+      expect(keyframes[0]).toEqual({
+        opacity: 0,
+        color: 'purple',
+        background: 'red',
+        offset: 0,
+      });
+    });
+    it('should set the to keyframe properly', () => {
+      animation.to('opacity', 0).to('background', 'red').to('color', 'purple');
+      const keyframes = animation.getKeyframes();
+      expect(keyframes.length).toEqual(1);
+      expect(keyframes[0]).toEqual({
+        opacity: 0,
+        color: 'purple',
+        background: 'red',
+        offset: 1,
+      });
+    });
+    it('should mix keyframes and fromTo properly', () => {
+      animation
+        .keyframes([
+        { offset: 0, background: 'red' },
+        { offset: 0.99, background: 'blue' },
+        { offset: 1, background: 'green' },
+      ])
+        .fromTo('opacity', 0, 1);
+      const keyframes = animation.getKeyframes();
+      expect(keyframes.length).toEqual(3);
+      expect(keyframes[0]).toEqual({
+        opacity: 0,
+        background: 'red',
+        offset: 0,
+      });
+      expect(keyframes[1]).toEqual({
+        background: 'blue',
+        offset: 0.99,
+      });
+      expect(keyframes[2]).toEqual({
+        opacity: 1,
+        background: 'green',
+        offset: 1,
+      });
+    });
+  });
+  describe('Animation Config Methods', () => {
+    let animation;
+    beforeEach(() => {
+      animation = createAnimation();
+    });
+    it('should get "linear" when easing not set', () => {
+      expect(animation.getEasing()).toEqual('linear');
+    });
+    it('should get parent easing when child easing is not set', () => {
+      const childAnimation = createAnimation();
+      animation.addAnimation(childAnimation).easing('ease-in-out');
+      expect(childAnimation.getEasing()).toEqual('ease-in-out');
+    });
+    it('should get prefer child easing over parent easing', () => {
+      const childAnimation = createAnimation();
+      childAnimation.easing('linear');
+      animation.addAnimation(childAnimation).easing('ease-in-out');
+      expect(childAnimation.getEasing()).toEqual('linear');
+    });
+    it('should get linear easing when forceLinear is set', () => {
+      animation.easing('ease-in-out');
+      animation.progressStart(true);
+      expect(animation.getEasing()).toEqual('linear');
+      animation.progressEnd(0, 0);
+      expect(animation.getEasing()).toEqual('ease-in-out');
+    });
+    it('should get 0 when duration not set', () => {
+      expect(animation.getDuration()).toEqual(0);
+    });
+    it('should get parent duration when child duration is not set', () => {
+      const childAnimation = createAnimation();
+      animation.addAnimation(childAnimation).duration(500);
+      expect(childAnimation.getDuration()).toEqual(500);
+    });
+    it('should get prefer child duration over parent duration', () => {
+      const childAnimation = createAnimation();
+      childAnimation.duration(500);
+      animation.addAnimation(childAnimation).duration(1000);
+      expect(childAnimation.getDuration()).toEqual(500);
+    });
+    it('should get 0 when delay not set', () => {
+      expect(animation.getDelay()).toEqual(0);
+    });
+    it('should get parent delay when child delay is not set', () => {
+      const childAnimation = createAnimation();
+      animation.addAnimation(childAnimation).delay(500);
+      expect(childAnimation.getDelay()).toEqual(500);
+    });
+    it('should get prefer child delay over parent delay', () => {
+      const childAnimation = createAnimation();
+      childAnimation.delay(500);
+      animation.addAnimation(childAnimation).delay(1000);
+      expect(childAnimation.getDelay()).toEqual(500);
+    });
+    it('should get 1 when iterations not set', () => {
+      expect(animation.getIterations()).toEqual(1);
+    });
+    it('should get parent iterations when child iterations is not set', () => {
+      const childAnimation = createAnimation();
+      animation.addAnimation(childAnimation).iterations(2);
+      expect(childAnimation.getIterations()).toEqual(2);
+    });
+    it('should get prefer child iterations over parent iterations', () => {
+      const childAnimation = createAnimation();
+      childAnimation.iterations(2);
+      animation.addAnimation(childAnimation).iterations(1);
+      expect(childAnimation.getIterations()).toEqual(2);
+    });
+    it('should get "both" when fill not set', () => {
+      expect(animation.getFill()).toEqual('both');
+    });
+    it('should get parent fill when child fill is not set', () => {
+      const childAnimation = createAnimation();
+      animation.addAnimation(childAnimation).fill('both');
+      expect(childAnimation.getFill()).toEqual('both');
+    });
+    it('should get prefer child fill over parent fill', () => {
+      const childAnimation = createAnimation();
+      childAnimation.fill('none');
+      animation.addAnimation(childAnimation).fill('forwards');
+      expect(childAnimation.getFill()).toEqual('none');
+    });
+    it('should get "normal" when direction not set', () => {
+      expect(animation.getDirection()).toEqual('normal');
+    });
+    it('should get parent direction when child direction is not set', () => {
+      const childAnimation = createAnimation();
+      animation.addAnimation(childAnimation).direction('alternate');
+      expect(childAnimation.getDirection()).toEqual('alternate');
+    });
+    it('should get prefer child direction over parent direction', () => {
+      const childAnimation = createAnimation();
+      childAnimation.direction('alternate-reverse');
+      animation.addAnimation(childAnimation).direction('normal');
+      expect(childAnimation.getDirection()).toEqual('alternate-reverse');
+    });
+  });
+});
+describe('cubic-bezier conversion', () => {
+  describe('should properly get a time value (x value) given a progression value (y value)', () => {
+    it('cubic-bezier(0.32, 0.72, 0, 1)', () => {
+      const equation = [
+        [0, 0],
+        [0.32, 0.72],
+        [0, 1],
+        [1, 1],
+      ];
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.5), [
+        0.16,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.97), [
+        0.56,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.33), [
+        0.11,
+      ]);
+    });
+    it('cubic-bezier(1, 0, 0.68, 0.28)', () => {
+      const equation = [
+        [0, 0],
+        [1, 0],
+        [0.68, 0.28],
+        [1, 1],
+      ];
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.08), [
+        0.6,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.5), [
+        0.84,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.94), [
+        0.98,
+      ]);
+    });
+    it('cubic-bezier(0.4, 0, 0.6, 1)', () => {
+      const equation = [
+        [0, 0],
+        [0.4, 0],
+        [0.6, 1],
+        [1, 1],
+      ];
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.39), [
+        0.43,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.03), [
+        0.11,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.89), [
+        0.78,
+      ]);
+    });
+    it('cubic-bezier(0, 0, 0.2, 1)', () => {
+      const equation = [
+        [0, 0],
+        [0, 0],
+        [0.2, 1],
+        [1, 1],
+      ];
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.95), [
+        0.71,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.1), [
+        0.03,
+      ]);
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 0.7), [
+        0.35,
+      ]);
+    });
+    it('cubic-bezier(0.32, 0.72, 0, 1) (with out of bounds progression)', () => {
+      const equation = [
+        [0, 0],
+        [0.05, 0.2],
+        [0.14, 1.72],
+        [1, 1],
+      ];
+      expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 1.32)[0]).toBeUndefined();
+      expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], -0.32)[0]).toBeUndefined();
+    });
+    it('cubic-bezier(0.21, 1.71, 0.88, 0.9) (multiple solutions)', () => {
+      const equation = [
+        [0, 0],
+        [0.21, 1.71],
+        [0.88, 0.9],
+        [1, 1],
+      ];
+      shouldApproximatelyEqual(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 1.02), [0.35, 0.87]);
+    });
+    it('cubic-bezier(0.32, 0.72, 0, 1) (with out of bounds progression)', () => {
+      const equation = [
+        [0, 0],
+        [0.05, 0.2],
+        [0.14, 1.72],
+        [1, 1],
+      ];
+      expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], 1.32)).toEqual([]);
+      expect(getTimeGivenProgression(equation[0], equation[1], equation[2], equation[3], -0.32)).toEqual([]);
+    });
+  });
+});
+const shouldApproximatelyEqual = (givenValues, expectedValues) => {
+  givenValues.forEach((givenValue, i) => {
+    expect(Math.abs(expectedValues[i] - givenValue)).toBeLessThanOrEqual(0.01);
+  });
+};

package/dist/collection/utils/keyboard/test/keyboard-controller.spec.js

@@ -0,0 +1,21 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { createKeyboardController } from "../keyboard-controller";
+describe('Keyboard Controller', () => {
+  it('should update isKeyboardVisible', async () => {
+    const keyboardCtrl = await createKeyboardController();
+    window.dispatchEvent(new Event('keyboardWillShow'));
+    expect(keyboardCtrl.isKeyboardVisible()).toBe(true);
+    window.dispatchEvent(new Event('keyboardWillHide'));
+    expect(keyboardCtrl.isKeyboardVisible()).toBe(false);
+  });
+  it('should run the callback', async () => {
+    const callbackMock = jest.fn();
+    await createKeyboardController(callbackMock);
+    window.dispatchEvent(new Event('keyboardWillShow'));
+    expect(callbackMock).toHaveBeenCalledWith(true, undefined);
+    window.dispatchEvent(new Event('keyboardWillHide'));
+    expect(callbackMock).toHaveBeenCalledWith(false, undefined);
+  });
+});

package/dist/collection/utils/keyboard/test/keyboard.spec.js

@@ -0,0 +1,214 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { copyVisualViewport, setKeyboardClose, setKeyboardOpen, keyboardDidClose, keyboardDidOpen, keyboardDidResize, resetKeyboardAssist, startKeyboardAssist, trackViewportChanges, KEYBOARD_DID_OPEN, KEYBOARD_DID_CLOSE, } from "../keyboard";
+const mockVisualViewport = (win, visualViewport = { width: 320, height: 568 }, layoutViewport = { innerWidth: 320, innerHeight: 568 }) => {
+  win.visualViewport = {
+    width: 320,
+    height: 568,
+    offsetTop: 0,
+    offsetLeft: 0,
+    pageTop: 0,
+    pageLeft: 0,
+    scale: 1,
+    onresize: undefined,
+    onscroll: undefined,
+  };
+  win.visualViewport = Object.assign(win.visualViewport, visualViewport);
+  win = Object.assign(win, layoutViewport);
+  const mockDispatchEvent = jest.fn();
+  win.dispatchEvent = mockDispatchEvent;
+  trackViewportChanges(win);
+  return {
+    win,
+    mockDispatchEvent,
+  };
+};
+const mockCapacitor = (win) => {
+  win.Capacitor = {
+    isPluginAvailable: () => false,
+  };
+};
+const resizeVisualViewport = (win, visualViewport = {}) => {
+  win.visualViewport = Object.assign(win.visualViewport, visualViewport);
+  if (win.visualViewport.onresize) {
+    win.visualViewport.onresize({});
+  }
+  else {
+    trackViewportChanges(win);
+  }
+};
+const resizeLayoutViewport = (win, layoutViewport = {}) => {
+  win = Object.assign(win, { innerWidth: layoutViewport.width, innerHeight: layoutViewport.height });
+};
+describe('Keyboard Assist Tests', () => {
+  describe('copyVisualViewport()', () => {
+    it('should properly copy the visual viewport', () => {
+      const visualViewport = {
+        width: 100,
+        height: 200,
+        offsetTop: 5,
+        offsetLeft: 10,
+        pageTop: 0,
+        pageLeft: 0,
+        scale: 2,
+      };
+      const copiedViewport = copyVisualViewport(visualViewport);
+      visualViewport.width = 400;
+      visualViewport.height = 800;
+      visualViewport.scale = 3;
+      visualViewport.offsetTop = 0;
+      expect(copiedViewport.width).toEqual(100);
+      expect(copiedViewport.height).toEqual(200);
+      expect(copiedViewport.scale).toEqual(2);
+      expect(copiedViewport.offsetTop).toEqual(5);
+    });
+  });
+  describe('setKeyboardOpen()', () => {
+    it('should dispatch the keyboard open event on the window', () => {
+      const mockDispatchEvent = jest.fn();
+      window.dispatchEvent = mockDispatchEvent;
+      setKeyboardOpen(window);
+      expect(mockDispatchEvent.mock.calls.length).toEqual(1);
+      expect(mockDispatchEvent.mock.calls[0][0].type).toEqual(KEYBOARD_DID_OPEN);
+    });
+  });
+  describe('setKeyboardClose()', () => {
+    it('should dispatch the keyboard close event on the window', () => {
+      const mockDispatchEvent = jest.fn();
+      window.dispatchEvent = mockDispatchEvent;
+      setKeyboardClose(window);
+      expect(mockDispatchEvent.mock.calls.length).toEqual(1);
+      expect(mockDispatchEvent.mock.calls[0][0].type).toEqual(KEYBOARD_DID_CLOSE);
+    });
+  });
+  describe('keyboardDidOpen()', () => {
+    beforeEach(() => {
+      resetKeyboardAssist();
+      mockVisualViewport(window);
+    });
+    it('should return true when visual viewport height < layout viewport height and meets or exceeds the keyboard threshold', () => {
+      resizeVisualViewport(window, { height: 200 });
+      expect(keyboardDidOpen()).toEqual(true);
+    });
+    it('should return true if the layout and visual viewports resize', () => {
+      resizeLayoutViewport(window, { width: 320, height: 300 });
+      resizeVisualViewport(window, { width: 320, height: 300 });
+      expect(keyboardDidOpen()).toEqual(true);
+    });
+    it('should return false when visual viewport height < layout viewport heigh but does not meet the keyboard threshold', () => {
+      resizeVisualViewport(window, { height: 500 });
+      expect(keyboardDidOpen()).toEqual(false);
+    });
+    it('should return false on orientation change', () => {
+      resizeVisualViewport(window, { width: 320, height: 250 });
+      resizeVisualViewport(window, { width: 250, height: 320 });
+      expect(keyboardDidOpen()).toEqual(false);
+    });
+    it('should return false when both the visual and layout viewports change', () => {
+      resizeVisualViewport(window, { width: 250, height: 320 });
+      expect(keyboardDidOpen()).toEqual(false);
+    });
+    it('should return true when the keyboard shows even if the user is zoomed in', () => {
+      // User zooms in
+      resizeVisualViewport(window, { width: 160, height: 284, scale: 2 });
+      // User taps input and keyboard appears
+      resizeVisualViewport(window, { width: 160, height: 184, scale: 2 });
+      expect(keyboardDidOpen()).toEqual(true);
+    });
+  });
+  describe('keyboardDidClose()', () => {
+    beforeEach(() => {
+      resetKeyboardAssist();
+      mockVisualViewport(window);
+    });
+    it('should return false when keyboard is not open', () => {
+      expect(keyboardDidClose(window)).toEqual(false);
+    });
+    it('should return false when keyboard is open but visual viewport !== layout viewport', () => {
+      resizeVisualViewport(window, { width: 320, height: 250 });
+      setKeyboardOpen(window);
+      expect(keyboardDidClose(window)).toEqual(false);
+    });
+    it('should return true when keyboard is open and viewport === layout viewport', () => {
+      resizeVisualViewport(window, { width: 320, height: 250 });
+      setKeyboardOpen(window);
+      resizeVisualViewport(window, { width: 320, height: 568 });
+      expect(keyboardDidClose(window)).toEqual(true);
+    });
+    it('should return false on orientation change', () => {
+      resizeVisualViewport(window, { width: 320, height: 250 });
+      setKeyboardOpen(window);
+      resizeVisualViewport(window, { width: 250, height: 320 });
+      expect(keyboardDidClose(window)).toEqual(false);
+    });
+  });
+  describe('keyboardDidResize()', () => {
+    it('should return true when the keyboard is open but did not close', () => {
+      mockVisualViewport(window, { width: 250, height: 320 });
+      setKeyboardOpen(window);
+      mockVisualViewport(window, { width: 250, height: 300 });
+      expect(keyboardDidResize(window)).toEqual(true);
+    });
+    it('should return false when the keyboard is not open', () => {
+      mockVisualViewport(window);
+      expect(keyboardDidResize(window)).toEqual(false);
+    });
+    it('should return false when the keyboard has closed', () => {
+      mockVisualViewport(window, { width: 320, height: 250 });
+      setKeyboardOpen(window);
+      setKeyboardClose(window);
+      expect(keyboardDidResize(window)).toEqual(false);
+    });
+  });
+});
+describe('Keyboard Assist Integration', () => {
+  let mockDispatchEvent;
+  beforeEach(() => {
+    resetKeyboardAssist();
+    mockDispatchEvent = mockVisualViewport(window).mockDispatchEvent;
+    startKeyboardAssist(window);
+  });
+  afterEach(() => {
+    mockDispatchEvent.mockReset();
+  });
+  it('should properly set the keyboard to be open', () => {
+    resizeVisualViewport(window, { width: 320, height: 350 });
+    expect(mockDispatchEvent.mock.calls.length).toEqual(1);
+    expect(mockDispatchEvent.mock.calls[0][0].type).toEqual(KEYBOARD_DID_OPEN);
+  });
+  it('should properly set the keyboard to be closed', () => {
+    resizeVisualViewport(window, { width: 320, height: 350 });
+    resizeVisualViewport(window, { width: 320, height: 568 });
+    expect(mockDispatchEvent.mock.calls.length).toEqual(2);
+    expect(mockDispatchEvent.mock.calls[1][0].type).toEqual(KEYBOARD_DID_CLOSE);
+  });
+  it('should properly set the keyboard to be resized', () => {
+    resizeVisualViewport(window, { width: 320, height: 350 });
+    resizeVisualViewport(window, { width: 320, height: 360 });
+    expect(mockDispatchEvent.mock.calls.length).toEqual(2);
+    expect(mockDispatchEvent.mock.calls[0][0].type).toEqual(KEYBOARD_DID_OPEN);
+    expect(mockDispatchEvent.mock.calls[1][0].type).toEqual(KEYBOARD_DID_OPEN);
+  });
+  it('should not set keyboard open on orientation change', () => {
+    resizeVisualViewport(window, { width: 568, height: 320 });
+    expect(mockDispatchEvent.mock.calls.length).toEqual(0);
+  });
+});
+describe('Keyboard Assist with Capacitor', () => {
+  let mockDispatchEvent;
+  beforeEach(() => {
+    resetKeyboardAssist();
+    mockCapacitor(window);
+    mockDispatchEvent = mockVisualViewport(window).mockDispatchEvent;
+    startKeyboardAssist(window);
+  });
+  afterEach(() => {
+    mockDispatchEvent.mockReset();
+  });
+  it('should attach visual viewport listeners when Capacitor is available but the Keyboard plugin is not', () => {
+    resizeVisualViewport(window, { width: 320, height: 350 });
+    expect(mockDispatchEvent.mock.calls.length).toEqual(1);
+    expect(mockDispatchEvent.mock.calls[0][0].type).toEqual(KEYBOARD_DID_OPEN);
+  });
+});