playbook_ui 14.16.0.pre.alpha.play1881removelodash6986 → 14.16.0.pre.alpha.play1957inlinedatepickericonbugfix6872

data/app/pb_kits/playbook/pb_tooltip/index.js

@@ -1,26 +1,22 @@
 import PbEnhancedElement from '../pb_enhanced_element'
-import { computePosition, offset, flip, shift, arrow, autoUpdate } from '@floating-ui/dom'
-
-const TOOLTIP_OFFSET = 20
+import {
+  createPopperLite as createPopper,
+  flip,
+  offset,
+  preventOverflow,
+} from '@popperjs/core'
+
+const TOOLTIP_OFFSET = [0, 20]
 const TOOLTIP_TIMEOUT = 250
-const SAFE_ZONE_MARGIN = 1
 
 export default class PbTooltip extends PbEnhancedElement {
   static get selector() {
-    return '[data-pb-tooltip-kit]'
+    return '[data-pb-tooltip-kit="true"][data-pb-tooltip-interaction="false"]:not([data-pb-tooltip-delay-open]):not([data-pb-tooltip-delay-close])'
   }
 
   connect() {
-    if (this.tooltipInteraction) {
-      document.addEventListener('mousemove', (e) => {
-        this.lastMouseX = e.clientX
-        this.lastMouseY = e.clientY
-      })
-    }
-    
     this.triggerElements.forEach((trigger) => {
       const method = this.triggerMethod
-      const interactionEnabled = this.tooltipInteraction
 
       if (method === 'click') {
         trigger.addEventListener('click', () => {
@@ -28,66 +24,29 @@ export default class PbTooltip extends PbEnhancedElement {
         })
       } else {
         trigger.addEventListener('mouseenter', () => {
-          clearSafeZoneListener(this)
-          clearTimeout(this.mouseleaveTimeout)
-          this.currentTrigger = trigger
-          const delayOpen = this.delayOpen ? parseInt(this.delayOpen) : TOOLTIP_TIMEOUT
           this.mouseenterTimeout = setTimeout(() => {
             this.showTooltip(trigger)
-            if (interactionEnabled) {
-              this.checkCloseTooltip(trigger)
-            }
-          }, delayOpen)
-        })
+            this.checkCloseTooltip(trigger)
+          }, TOOLTIP_TIMEOUT)
 
-        trigger.addEventListener('mouseleave', () => {
-          clearTimeout(this.mouseenterTimeout)
-          if (this.delayClose) {
-            const delayClose = parseInt(this.delayClose)
-            this.mouseleaveTimeout = setTimeout(() => {
-              if (interactionEnabled) {
-                this.attachSafeZoneListener()
-              } else {
-                this.hideTooltip()
-              }
-            }, delayClose)
-          } else {
-            if (interactionEnabled) {
-              this.attachSafeZoneListener()
-            } else {
+          trigger.addEventListener('mouseleave', () => {
+            clearTimeout(this.mouseenterTimeout)
+            setTimeout(() => {
               this.hideTooltip()
-            }
-          }
+            }, 0)
+          }, { once: true })
         })
 
-        if (interactionEnabled) {
-          this.tooltip.addEventListener('mouseenter', () => {
-            clearSafeZoneListener(this)
-          })
-
-          this.tooltip.addEventListener('mouseleave', () => {
-            this.attachSafeZoneListener()
-          })
-        }
+        this.tooltip.addEventListener('mouseenter', () => {
+          clearTimeout(this.mouseenterTimeout)
+        })
+        this.tooltip.addEventListener('mouseleave', () => {
+          this.hideTooltip()
+        })
       }
     })
   }
 
-  attachSafeZoneListener() {
-    clearSafeZoneListener(this)
-    this.safeZoneHandler = (e) => {
-      if (!this.currentTrigger) return
-      const triggerRect = this.currentTrigger.getBoundingClientRect()
-      const tooltipRect = this.tooltip.getBoundingClientRect()
-      const safeRect = getSafeZone(triggerRect, tooltipRect, this.position, SAFE_ZONE_MARGIN)
-      if (!isPointInsideRect(e.clientX, e.clientY, safeRect)) {
-        this.hideTooltip()
-        clearSafeZoneListener(this)
-      }
-    }
-    document.addEventListener('mousemove', this.safeZoneHandler)
-  }
-
   checkCloseTooltip(trigger) {
     document.querySelector('body').addEventListener('click', ({ target }) => {
       const isTooltip = target.closest(`#${this.tooltipId}`) === this.tooltip
@@ -103,46 +62,27 @@ export default class PbTooltip extends PbEnhancedElement {
   showTooltip(trigger) {
     if (this.shouldShowTooltip === 'false') return
 
-    clearSafeZoneListener(this)
-
-    this.tooltip.style.opacity = '1'
-    this.tooltip.style.visibility = 'visible'
-    this.tooltip.style.pointerEvents = 'auto'
-
-    if (this.cleanup) {
-      this.cleanup()
-    }
-
-    const arrowElement = document.querySelector(`#${this.tooltipId}-arrow`)
-
-    this.cleanup = autoUpdate(trigger, this.tooltip, () => {
-      computePosition(trigger, this.tooltip, {
-        placement: this.position,
-        strategy: 'fixed',
-        middleware: [
-          offset({ mainAxis: TOOLTIP_OFFSET, crossAxis: 0 }),
-          flip(),
-          shift(),
-          arrow({ element: arrowElement })
-        ],
-      }).then(({ x, y, placement, middlewareData }) => {
-        Object.assign(this.tooltip.style, {
-          left: `${x}px`,
-          top: `${y}px`,
-          position: 'fixed'
-        })
-        this.tooltip.setAttribute('data-popper-placement', placement)
-        if (arrowElement && middlewareData.arrow) {
-          const { x: arrowX, y: arrowY } = middlewareData.arrow
-          Object.assign(arrowElement.style, {
-            left: arrowX != null ? `${arrowX}px` : '',
-            top: arrowY != null ? `${arrowY}px` : '',
-            position: 'absolute'
-          })
-        }
-      })
+    this.popper = createPopper(trigger, this.tooltip, {
+      placement: this.position,
+      strategy: 'fixed',
+      modifiers: [
+        {
+          name: 'offset',
+          options: {
+            offset: TOOLTIP_OFFSET,
+          },
+        },
+        {
+          name: 'arrow',
+          options: {
+            element: document.querySelector(`#${this.tooltipId}-arrow`),
+          },
+        },
+        offset,
+        preventOverflow,
+        flip,
+      ],
     })
-
     this.tooltip.classList.add('show')
 
     if (this.triggerMethod === 'click') {
@@ -154,50 +94,39 @@ export default class PbTooltip extends PbEnhancedElement {
   }
 
   hideTooltip() {
-    if (!this.tooltip) return
-
     this.tooltip.classList.add('fade_out')
     setTimeout(() => {
-      if (this.cleanup) {
-        this.cleanup()
-        this.cleanup = null
-      }
+      if (!this.popper) return
+      this.popper.destroy()
       this.tooltip.classList.remove('show')
       this.tooltip.classList.remove('fade_out')
-      this.tooltip.style.opacity = '0'
-      this.tooltip.style.visibility = 'hidden'
-      this.tooltip.style.pointerEvents = 'none'
-      this.tooltip.style.position = ''
-      this.tooltip.style.top = ''
-      this.tooltip.style.left = ''
-      this.tooltip.style.transform = ''
     }, TOOLTIP_TIMEOUT)
   }
 
   get triggerElements() {
     let triggerEl
+
     if (this.triggerElementId) {
       triggerEl = document.querySelector(`#${this.triggerElementId}`)
-    } else if (this.triggerElementSelector) {
+    } else {
       const selectorIsId = this.triggerElementSelector.indexOf('#') > -1
       triggerEl = selectorIsId
-        ? document.querySelector(this.triggerElementSelector)
-        : document.querySelectorAll(this.triggerElementSelector)
-    } else {
-      triggerEl = this.element
+        ? document.querySelector(`${this.triggerElementSelector}`)
+        : document.querySelectorAll(`${this.triggerElementSelector}`)
     }
+
     if (!triggerEl) {
-      console.error('Tooltip Kit: No valid trigger element found!')
+      console.error('Tooltip Kit: an invalid or unavailable DOM reference was provided!')
       return []
     }
-    if (triggerEl.length === undefined) {
-      triggerEl = [triggerEl]
-    }
-    return triggerEl
+
+    if (!triggerEl.length) triggerEl = [triggerEl]
+    return (this._triggerElements = this._triggerElements || triggerEl)
   }
 
   get tooltip() {
-    return (this._tooltip = this._tooltip || this.element.querySelector(`#${this.tooltipId}`))
+    return (this._tooltip =
+      this._tooltip || this.element.querySelector(`#${this.tooltipId}`))
   }
 
   get position() {
@@ -223,60 +152,4 @@ export default class PbTooltip extends PbEnhancedElement {
   get triggerMethod() {
     return this.element.dataset.pbTooltipTriggerMethod || 'hover'
   }
-
-  get tooltipInteraction() {
-    return this.element.dataset.pbTooltipInteraction === 'true'
-  }
-  
-  get delayOpen() {
-    return this.element.dataset.pbTooltipDelayOpen
-  }
-  
-  get delayClose() {
-    return this.element.dataset.pbTooltipDelayClose
-  }
-}
-
-function clearSafeZoneListener(context) {
-  if (context.safeZoneHandler) {
-    document.removeEventListener('mousemove', context.safeZoneHandler)
-    context.safeZoneHandler = null
-  }
-}
-
-function getSafeZone(triggerRect, tooltipRect, placement, margin) {
-  let safeRect = {}
-  if (placement.startsWith('top')) {
-    safeRect.left = triggerRect.left - margin
-    safeRect.right = triggerRect.right + margin
-    safeRect.top = tooltipRect.bottom - margin
-    safeRect.bottom = triggerRect.top + margin
-  } else if (placement.startsWith('bottom')) {
-    safeRect.left = triggerRect.left - margin
-    safeRect.right = triggerRect.right + margin
-    safeRect.top = triggerRect.bottom - margin
-    safeRect.bottom = tooltipRect.top + margin
-  } else if (placement.startsWith('left')) {
-    safeRect.top = triggerRect.top - margin
-    safeRect.bottom = triggerRect.bottom + margin
-    safeRect.left = tooltipRect.right - margin
-    safeRect.right = triggerRect.left + margin
-  } else if (placement.startsWith('right')) {
-    safeRect.top = triggerRect.top - margin
-    safeRect.bottom = triggerRect.bottom + margin
-    safeRect.left = triggerRect.right - margin
-    safeRect.right = tooltipRect.left + margin
-  } else {
-    safeRect = {
-      left: triggerRect.left - margin,
-      right: triggerRect.right + margin,
-      top: triggerRect.top - margin,
-      bottom: triggerRect.bottom + margin,
-    }
-  }
-  return safeRect
-}
-
-function isPointInsideRect(x, y, rect) {
-  return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom
-}
+}

data/app/pb_kits/playbook/pb_typeahead/docs/_typeahead_with_highlight.jsx

@@ -18,18 +18,18 @@ const USERS = [
     territory: "PHL",
   },
   {
-    name: "Carlos Lima",
-    title: "Nitro Developer",
+    name: "Jason Cypret",
+    title: "Vice President of User Experience",
     territory: "PHL",
   },
   {
     name: "Stephen Marshall",
-    title: "Senior Nitro Developer",
+    title: "Senior User Experience Engineer",
     territory: "PHL",
   },
   {
     name: "Jasper Furniss",
-    title: "Lead User Experience Engineer",
+    title: "Senior User Experience Engineer",
     territory: "PHL",
   },
 ];

data/app/pb_kits/playbook/pb_typeahead/index.ts

@@ -1,5 +1,5 @@
 import PbEnhancedElement from '../pb_enhanced_element'
-import { debounce } from '../utilities/object'
+import { debounce } from 'lodash'
 
 export default class PbTypeahead extends PbEnhancedElement {
   _searchInput: HTMLInputElement
@@ -284,4 +284,4 @@ export default class PbTypeahead extends PbEnhancedElement {
     if (visible) visibilityProperty = '1'
     this.resultsLoadingIndicator.style.opacity = visibilityProperty
   }
-}
+}

data/app/pb_kits/playbook/utilities/globalProps.ts

@@ -1,4 +1,4 @@
-import { omit } from './object'
+import { omit } from 'lodash'
 import { camelToSnakeCase } from './text'
 
 import {

data/app/pb_kits/playbook/utilities/object.test.js

@@ -1,4 +1,4 @@
-import { isEmpty, get, isString, uniqueId, omitBy, noop, merge, filter, find, partial, map, cloneDeep, omit, debounce } from './object';
+import { isEmpty, get, isString, uniqueId, omitBy, noop, merge, filter, find, partial } from './object';
 
 describe('Lodash functions', () => {
   describe('isEmpty', () => {
@@ -234,152 +234,4 @@ describe('Lodash functions', () => {
       expect(joinPartial('b', 'c')).toBe('a_b_c');
     });
   });
-
-  describe('map', () => {
-    test('maps over an array with a function iteratee', () => {
-      const arr = [1, 2, 3];
-      const result = map(arr, (num) => num * 2);
-      expect(result).toEqual([2, 4, 6]);
-    });
-
-    test('maps over an array with a string iteratee', () => {
-      const arr = [{ value: 1 }, { value: 2 }, { value: 3 }];
-      const result = map(arr, 'value');
-      expect(result).toEqual([1, 2, 3]);
-    });
-
-    test('maps over an object with a function iteratee', () => {
-      const obj = { a: 1, b: 2, c: 3 };
-      const result = map(obj, (val, key) => key + val);
-      expect(result.sort()).toEqual(['a1', 'b2', 'c3'].sort());
-    });
-
-    test('maps over an object with a string iteratee', () => {
-      const obj = {
-        one: { num: 1 },
-        two: { num: 2 },
-        three: { num: 3 },
-      };
-      const result = map(obj, 'num');
-      expect(result.sort()).toEqual([1, 2, 3].sort());
-    });
-
-    test('returns original values if no iteratee provided', () => {
-      const arr = [1, 2, 3];
-      const result = map(arr);
-      expect(result).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('cloneDeep', () => {
-    test('clones primitive values', () => {
-      expect(cloneDeep(42)).toBe(42);
-      expect(cloneDeep('test')).toBe('test');
-      expect(cloneDeep(null)).toBe(null);
-    });
-
-    test('clones arrays deeply', () => {
-      const arr = [1, [2, 3]];
-      const cloned = cloneDeep(arr);
-      expect(cloned).toEqual(arr);
-      cloned[1][0] = 99;
-      expect(arr[1][0]).toBe(2);
-    });
-
-    test('clones objects deeply', () => {
-      const obj = { a: { b: 2 } };
-      const cloned = cloneDeep(obj);
-      expect(cloned).toEqual(obj);
-      cloned.a.b = 99;
-      expect(obj.a.b).toBe(2);
-    });
-
-    test('clones Date objects', () => {
-      const date = new Date();
-      const cloned = cloneDeep(date);
-      expect(cloned).not.toBe(date);
-      expect(cloned.getTime()).toBe(date.getTime());
-    });
-
-    test('clones RegExp objects', () => {
-      const regex = /test/gi;
-      const cloned = cloneDeep(regex);
-      expect(cloned).not.toBe(regex);
-      expect(cloned.source).toBe(regex.source);
-      expect(cloned.flags).toBe(regex.flags);
-    });
-  });
-
-  describe('omit', () => {
-    test('omits specified keys from object', () => {
-      const obj = { a: 1, b: 2, c: 3 };
-      expect(omit(obj, 'a', 'c')).toEqual({ b: 2 });
-    });
-
-    test('supports array of keys to omit', () => {
-      const obj = { a: 1, b: 2, c: 3 };
-      expect(omit(obj, ['b'])).toEqual({ a: 1, c: 3 });
-    });
-
-    test('returns empty object for null or non-object input', () => {
-      expect(omit(null, 'a')).toEqual({});
-      expect(omit("string", 'a')).toEqual({});
-    });
-
-    test('returns original object if no keys match', () => {
-      const obj = { a: 1, b: 2 };
-      expect(omit(obj, 'c')).toEqual({ a: 1, b: 2 });
-    });
-  });
-
-  describe('debounce', () => {
-    beforeEach(() => {
-      jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-      jest.useRealTimers();
-    });
-
-    test('delays execution until wait time has passed', () => {
-      const func = jest.fn();
-      const debounced = debounce(func, 1000);
-      debounced();
-      expect(func).not.toHaveBeenCalled();
-      jest.advanceTimersByTime(500);
-      expect(func).not.toHaveBeenCalled();
-      jest.advanceTimersByTime(500);
-      expect(func).toHaveBeenCalledTimes(1);
-    });
-
-    test('calls function only once when called repeatedly', () => {
-      const func = jest.fn();
-      const debounced = debounce(func, 1000);
-      debounced();
-      debounced();
-      debounced();
-      jest.advanceTimersByTime(1000);
-      expect(func).toHaveBeenCalledTimes(1);
-    });
-
-    test('immediate option calls function on first call', () => {
-      const func = jest.fn();
-      const debounced = debounce(func, 1000, true);
-      debounced();
-      expect(func).toHaveBeenCalledTimes(1);
-      debounced();
-      debounced();
-      jest.advanceTimersByTime(1000);
-      expect(func).toHaveBeenCalledTimes(1);
-    });
-
-    test('subsequent call after wait period works with immediate option', () => {
-      const func = jest.fn();
-      const debounced = debounce(func, 1000, true);
-      debounced();
-      jest.advanceTimersByTime(1100);
-      debounced();
-      expect(func).toHaveBeenCalledTimes(2);
-    });
-  });
 });